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
17 impl ::fidl_next::Encodable for Availability {
18 type Encoded = crate::wire::Availability;
19 }
20 impl ::core::convert::TryFrom<u32> for Availability {
21 type Error = ::fidl_next::UnknownStrictEnumMemberError;
22 fn try_from(
23 value: u32,
24 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
25 match value {
26 1 => Ok(Self::Required),
27 2 => Ok(Self::Optional),
28 3 => Ok(Self::SameAsTarget),
29 4 => Ok(Self::Transitional),
30
31 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
32 }
33 }
34 }
35
36 unsafe impl<___E> ::fidl_next::Encode<___E> for Availability
37 where
38 ___E: ?Sized,
39 {
40 #[inline]
41 fn encode(
42 self,
43 encoder: &mut ___E,
44 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
45 _: (),
46 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
47 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
48 }
49 }
50
51 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Availability
52 where
53 ___E: ?Sized,
54 {
55 #[inline]
56 fn encode_ref(
57 &self,
58 encoder: &mut ___E,
59 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
60 _: (),
61 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
62 ::fidl_next::munge!(let crate::wire::Availability { value } = out);
63 let _ = value.write(::fidl_next::WireU32::from(match *self {
64 Self::Required => 1,
65
66 Self::Optional => 2,
67
68 Self::SameAsTarget => 3,
69
70 Self::Transitional => 4,
71 }));
72
73 Ok(())
74 }
75 }
76
77 impl ::core::convert::From<crate::wire::Availability> for Availability {
78 fn from(wire: crate::wire::Availability) -> Self {
79 match u32::from(wire.value) {
80 1 => Self::Required,
81
82 2 => Self::Optional,
83
84 3 => Self::SameAsTarget,
85
86 4 => Self::Transitional,
87
88 _ => unsafe { ::core::hint::unreachable_unchecked() },
89 }
90 }
91 }
92
93 impl ::fidl_next::FromWire<crate::wire::Availability> for Availability {
94 #[inline]
95 fn from_wire(wire: crate::wire::Availability) -> Self {
96 Self::from(wire)
97 }
98 }
99
100 impl ::fidl_next::FromWireRef<crate::wire::Availability> for Availability {
101 #[inline]
102 fn from_wire_ref(wire: &crate::wire::Availability) -> Self {
103 Self::from(*wire)
104 }
105 }
106
107 #[derive(PartialEq, Clone, Debug)]
108 #[repr(C)]
109 pub struct Unit {}
110
111 impl ::fidl_next::Encodable for Unit {
112 type Encoded = crate::wire::Unit;
113 }
114
115 unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
116 where
117 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
118 {
119 #[inline]
120 fn encode(
121 self,
122 encoder_: &mut ___E,
123 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
124 _: (),
125 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
126 *out_ = ::core::mem::MaybeUninit::zeroed();
127
128 Ok(())
129 }
130 }
131
132 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unit
133 where
134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
135 {
136 #[inline]
137 fn encode_ref(
138 &self,
139 encoder_: &mut ___E,
140 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
141 _: (),
142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
143 ::fidl_next::munge! {
144 let Self::Encoded {
145
146 _empty,
147
148
149 } = out_;
150 }
151
152 Ok(())
153 }
154 }
155
156 impl ::fidl_next::EncodableOption for Unit {
157 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Unit>;
158 }
159
160 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unit
161 where
162 ___E: ::fidl_next::Encoder + ?Sized,
163 Unit: ::fidl_next::Encode<___E>,
164 {
165 #[inline]
166 fn encode_option(
167 this: ::core::option::Option<Self>,
168 encoder: &mut ___E,
169 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
170 _: (),
171 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
172 if let Some(inner) = this {
173 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
174 ::fidl_next::WireBox::encode_present(out);
175 } else {
176 ::fidl_next::WireBox::encode_absent(out);
177 }
178
179 Ok(())
180 }
181 }
182
183 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unit
184 where
185 ___E: ::fidl_next::Encoder + ?Sized,
186 Unit: ::fidl_next::EncodeRef<___E>,
187 {
188 #[inline]
189 fn encode_option_ref(
190 this: ::core::option::Option<&Self>,
191 encoder: &mut ___E,
192 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
193 _: (),
194 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
195 if let Some(inner) = this {
196 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
197 ::fidl_next::WireBox::encode_present(out);
198 } else {
199 ::fidl_next::WireBox::encode_absent(out);
200 }
201
202 Ok(())
203 }
204 }
205
206 impl ::fidl_next::FromWire<crate::wire::Unit> for Unit {
207 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unit, Self> =
208 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
209
210 #[inline]
211 fn from_wire(wire: crate::wire::Unit) -> Self {
212 Self {}
213 }
214 }
215
216 impl ::fidl_next::FromWireRef<crate::wire::Unit> for Unit {
217 #[inline]
218 fn from_wire_ref(wire: &crate::wire::Unit) -> Self {
219 Self {}
220 }
221 }
222
223 #[derive(PartialEq, Clone, Debug)]
224 pub enum Data {
225 Bytes(::std::vec::Vec<u8>),
226
227 String(::std::string::String),
228
229 Int64(i64),
230
231 Uint64(u64),
232
233 UnknownOrdinal_(u64),
234 }
235
236 impl Data {
237 pub fn is_unknown(&self) -> bool {
238 #[allow(unreachable_patterns)]
239 match self {
240 Self::UnknownOrdinal_(_) => true,
241 _ => false,
242 }
243 }
244 }
245
246 impl ::fidl_next::Encodable for Data {
247 type Encoded = crate::wire::Data<'static>;
248 }
249
250 unsafe impl<___E> ::fidl_next::Encode<___E> for Data
251 where
252 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
253 ___E: ::fidl_next::Encoder,
254 {
255 #[inline]
256 fn encode(
257 self,
258 encoder: &mut ___E,
259 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
260 _: (),
261 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
262 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
263
264 match self {
265 Self::Bytes(value) => ::fidl_next::RawWireUnion::encode_as::<
266 ___E,
267 ::std::vec::Vec<u8>,
268 >(value, 1, encoder, raw, (8192, ()))?,
269
270 Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
271 ___E,
272 ::std::string::String,
273 >(value, 2, encoder, raw, 8192)?,
274
275 Self::Int64(value) => {
276 ::fidl_next::RawWireUnion::encode_as::<___E, i64>(value, 3, encoder, raw, ())?
277 }
278
279 Self::Uint64(value) => {
280 ::fidl_next::RawWireUnion::encode_as::<___E, u64>(value, 4, encoder, raw, ())?
281 }
282
283 Self::UnknownOrdinal_(ordinal) => {
284 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
285 }
286 }
287
288 Ok(())
289 }
290 }
291
292 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Data
293 where
294 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
295 ___E: ::fidl_next::Encoder,
296 {
297 #[inline]
298 fn encode_ref(
299 &self,
300 encoder: &mut ___E,
301 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
302 _: (),
303 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
304 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
305
306 match self {
307 Self::Bytes(value) => ::fidl_next::RawWireUnion::encode_as::<
308 ___E,
309 &::std::vec::Vec<u8>,
310 >(value, 1, encoder, raw, (8192, ()))?,
311
312 Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
313 ___E,
314 &::std::string::String,
315 >(value, 2, encoder, raw, 8192)?,
316
317 Self::Int64(value) => {
318 ::fidl_next::RawWireUnion::encode_as::<___E, &i64>(value, 3, encoder, raw, ())?
319 }
320
321 Self::Uint64(value) => {
322 ::fidl_next::RawWireUnion::encode_as::<___E, &u64>(value, 4, encoder, raw, ())?
323 }
324
325 Self::UnknownOrdinal_(ordinal) => {
326 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
327 }
328 }
329
330 Ok(())
331 }
332 }
333
334 impl ::fidl_next::EncodableOption for Data {
335 type EncodedOption = crate::wire_optional::Data<'static>;
336 }
337
338 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Data
339 where
340 ___E: ?Sized,
341 Data: ::fidl_next::Encode<___E>,
342 {
343 #[inline]
344 fn encode_option(
345 this: ::core::option::Option<Self>,
346 encoder: &mut ___E,
347 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
348 _: (),
349 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
350 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
351
352 if let Some(inner) = this {
353 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
354 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
355 } else {
356 ::fidl_next::RawWireUnion::encode_absent(raw);
357 }
358
359 Ok(())
360 }
361 }
362
363 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Data
364 where
365 ___E: ?Sized,
366 Data: ::fidl_next::EncodeRef<___E>,
367 {
368 #[inline]
369 fn encode_option_ref(
370 this: ::core::option::Option<&Self>,
371 encoder: &mut ___E,
372 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
373 _: (),
374 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
375 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
376
377 if let Some(inner) = this {
378 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
379 ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out, ())?;
380 } else {
381 ::fidl_next::RawWireUnion::encode_absent(raw);
382 }
383
384 Ok(())
385 }
386 }
387
388 impl<'de> ::fidl_next::FromWire<crate::wire::Data<'de>> for Data {
389 #[inline]
390 fn from_wire(wire: crate::wire::Data<'de>) -> Self {
391 let wire = ::core::mem::ManuallyDrop::new(wire);
392 match wire.raw.ordinal() {
393 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
394 wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
395 })),
396
397 2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
398 wire.raw.get().read_unchecked::<::fidl_next::WireString<'de>>()
399 })),
400
401 3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
402 wire.raw.get().read_unchecked::<::fidl_next::WireI64>()
403 })),
404
405 4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
406 wire.raw.get().read_unchecked::<::fidl_next::WireU64>()
407 })),
408
409 ord => return Self::UnknownOrdinal_(ord as u64),
410 }
411 }
412 }
413
414 impl<'de> ::fidl_next::FromWireRef<crate::wire::Data<'de>> for Data {
415 #[inline]
416 fn from_wire_ref(wire: &crate::wire::Data<'de>) -> Self {
417 match wire.raw.ordinal() {
418 1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
419 wire.raw.get().deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
420 })),
421
422 2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
423 wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
424 })),
425
426 3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
427 wire.raw.get().deref_unchecked::<::fidl_next::WireI64>()
428 })),
429
430 4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
431 wire.raw.get().deref_unchecked::<::fidl_next::WireU64>()
432 })),
433
434 ord => return Self::UnknownOrdinal_(ord as u64),
435 }
436 }
437 }
438
439 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Data {
440 #[inline]
441 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
442 if let Some(inner) = wire.into_option() {
443 Some(::fidl_next::FromWire::from_wire(inner))
444 } else {
445 None
446 }
447 }
448 }
449
450 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Box<Data> {
451 #[inline]
452 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
453 <
454 Data as ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>>
455 >::from_wire_option(wire).map(Box::new)
456 }
457 }
458
459 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::Data<'de>> for Box<Data> {
460 #[inline]
461 fn from_wire_option_ref(
462 wire: &crate::wire_optional::Data<'de>,
463 ) -> ::core::option::Option<Self> {
464 if let Some(inner) = wire.as_ref() {
465 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
466 } else {
467 None
468 }
469 }
470 }
471
472 #[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
473 pub type Token = ::fidl_next::fuchsia::zx::EventPair;
474
475 #[derive(PartialEq, Debug)]
476 #[repr(C)]
477 pub struct DictionaryRef {
478 pub token: ::fidl_next::fuchsia::zx::EventPair,
479 }
480
481 impl ::fidl_next::Encodable for DictionaryRef {
482 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DictionaryRef> = unsafe {
483 ::fidl_next::CopyOptimization::enable_if(
484 true
485
486 && <
487 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
488 >::COPY_OPTIMIZATION.is_enabled()
489
490 )
491 };
492
493 type Encoded = crate::wire::DictionaryRef;
494 }
495
496 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRef
497 where
498 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
499 ___E: ::fidl_next::fuchsia::HandleEncoder,
500 {
501 #[inline]
502 fn encode(
503 self,
504 encoder_: &mut ___E,
505 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
506 _: (),
507 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
508 ::fidl_next::munge! {
509 let Self::Encoded {
510 token,
511
512 } = out_;
513 }
514
515 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
516
517 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
518
519 Ok(())
520 }
521 }
522
523 impl ::fidl_next::EncodableOption for DictionaryRef {
524 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DictionaryRef>;
525 }
526
527 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRef
528 where
529 ___E: ::fidl_next::Encoder + ?Sized,
530 DictionaryRef: ::fidl_next::Encode<___E>,
531 {
532 #[inline]
533 fn encode_option(
534 this: ::core::option::Option<Self>,
535 encoder: &mut ___E,
536 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
537 _: (),
538 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
539 if let Some(inner) = this {
540 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
541 ::fidl_next::WireBox::encode_present(out);
542 } else {
543 ::fidl_next::WireBox::encode_absent(out);
544 }
545
546 Ok(())
547 }
548 }
549
550 impl ::fidl_next::FromWire<crate::wire::DictionaryRef> for DictionaryRef {
551 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DictionaryRef, Self> = unsafe {
552 ::fidl_next::CopyOptimization::enable_if(
553 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
554 ::fidl_next::fuchsia::WireEventPair,
555 >>::COPY_OPTIMIZATION
556 .is_enabled(),
557 )
558 };
559
560 #[inline]
561 fn from_wire(wire: crate::wire::DictionaryRef) -> Self {
562 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
563 }
564 }
565
566 #[derive(PartialEq, Debug)]
567 #[repr(C)]
568 pub struct Connector {
569 pub token: ::fidl_next::fuchsia::zx::EventPair,
570 }
571
572 impl ::fidl_next::Encodable for Connector {
573 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Connector> = unsafe {
574 ::fidl_next::CopyOptimization::enable_if(
575 true
576
577 && <
578 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
579 >::COPY_OPTIMIZATION.is_enabled()
580
581 )
582 };
583
584 type Encoded = crate::wire::Connector;
585 }
586
587 unsafe impl<___E> ::fidl_next::Encode<___E> for Connector
588 where
589 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
590 ___E: ::fidl_next::fuchsia::HandleEncoder,
591 {
592 #[inline]
593 fn encode(
594 self,
595 encoder_: &mut ___E,
596 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
597 _: (),
598 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
599 ::fidl_next::munge! {
600 let Self::Encoded {
601 token,
602
603 } = out_;
604 }
605
606 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
607
608 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
609
610 Ok(())
611 }
612 }
613
614 impl ::fidl_next::EncodableOption for Connector {
615 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Connector>;
616 }
617
618 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Connector
619 where
620 ___E: ::fidl_next::Encoder + ?Sized,
621 Connector: ::fidl_next::Encode<___E>,
622 {
623 #[inline]
624 fn encode_option(
625 this: ::core::option::Option<Self>,
626 encoder: &mut ___E,
627 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
628 _: (),
629 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
630 if let Some(inner) = this {
631 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
632 ::fidl_next::WireBox::encode_present(out);
633 } else {
634 ::fidl_next::WireBox::encode_absent(out);
635 }
636
637 Ok(())
638 }
639 }
640
641 impl ::fidl_next::FromWire<crate::wire::Connector> for Connector {
642 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Connector, Self> = unsafe {
643 ::fidl_next::CopyOptimization::enable_if(
644 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
645 ::fidl_next::fuchsia::WireEventPair,
646 >>::COPY_OPTIMIZATION
647 .is_enabled(),
648 )
649 };
650
651 #[inline]
652 fn from_wire(wire: crate::wire::Connector) -> Self {
653 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
654 }
655 }
656
657 #[derive(PartialEq, Debug)]
658 #[repr(C)]
659 pub struct DirConnector {
660 pub token: ::fidl_next::fuchsia::zx::EventPair,
661 }
662
663 impl ::fidl_next::Encodable for DirConnector {
664 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirConnector> = unsafe {
665 ::fidl_next::CopyOptimization::enable_if(
666 true
667
668 && <
669 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
670 >::COPY_OPTIMIZATION.is_enabled()
671
672 )
673 };
674
675 type Encoded = crate::wire::DirConnector;
676 }
677
678 unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnector
679 where
680 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
681 ___E: ::fidl_next::fuchsia::HandleEncoder,
682 {
683 #[inline]
684 fn encode(
685 self,
686 encoder_: &mut ___E,
687 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
688 _: (),
689 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
690 ::fidl_next::munge! {
691 let Self::Encoded {
692 token,
693
694 } = out_;
695 }
696
697 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
698
699 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
700
701 Ok(())
702 }
703 }
704
705 impl ::fidl_next::EncodableOption for DirConnector {
706 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirConnector>;
707 }
708
709 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnector
710 where
711 ___E: ::fidl_next::Encoder + ?Sized,
712 DirConnector: ::fidl_next::Encode<___E>,
713 {
714 #[inline]
715 fn encode_option(
716 this: ::core::option::Option<Self>,
717 encoder: &mut ___E,
718 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
719 _: (),
720 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
721 if let Some(inner) = this {
722 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
723 ::fidl_next::WireBox::encode_present(out);
724 } else {
725 ::fidl_next::WireBox::encode_absent(out);
726 }
727
728 Ok(())
729 }
730 }
731
732 impl ::fidl_next::FromWire<crate::wire::DirConnector> for DirConnector {
733 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirConnector, Self> = unsafe {
734 ::fidl_next::CopyOptimization::enable_if(
735 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
736 ::fidl_next::fuchsia::WireEventPair,
737 >>::COPY_OPTIMIZATION
738 .is_enabled(),
739 )
740 };
741
742 #[inline]
743 fn from_wire(wire: crate::wire::DirConnector) -> Self {
744 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
745 }
746 }
747
748 #[derive(PartialEq, Debug)]
749 #[repr(C)]
750 pub struct DirEntry {
751 pub token: ::fidl_next::fuchsia::zx::EventPair,
752 }
753
754 impl ::fidl_next::Encodable for DirEntry {
755 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirEntry> = unsafe {
756 ::fidl_next::CopyOptimization::enable_if(
757 true
758
759 && <
760 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
761 >::COPY_OPTIMIZATION.is_enabled()
762
763 )
764 };
765
766 type Encoded = crate::wire::DirEntry;
767 }
768
769 unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntry
770 where
771 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
772 ___E: ::fidl_next::fuchsia::HandleEncoder,
773 {
774 #[inline]
775 fn encode(
776 self,
777 encoder_: &mut ___E,
778 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
779 _: (),
780 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
781 ::fidl_next::munge! {
782 let Self::Encoded {
783 token,
784
785 } = out_;
786 }
787
788 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
789
790 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
791
792 Ok(())
793 }
794 }
795
796 impl ::fidl_next::EncodableOption for DirEntry {
797 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirEntry>;
798 }
799
800 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntry
801 where
802 ___E: ::fidl_next::Encoder + ?Sized,
803 DirEntry: ::fidl_next::Encode<___E>,
804 {
805 #[inline]
806 fn encode_option(
807 this: ::core::option::Option<Self>,
808 encoder: &mut ___E,
809 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
810 _: (),
811 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
812 if let Some(inner) = this {
813 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
814 ::fidl_next::WireBox::encode_present(out);
815 } else {
816 ::fidl_next::WireBox::encode_absent(out);
817 }
818
819 Ok(())
820 }
821 }
822
823 impl ::fidl_next::FromWire<crate::wire::DirEntry> for DirEntry {
824 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirEntry, Self> = unsafe {
825 ::fidl_next::CopyOptimization::enable_if(
826 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
827 ::fidl_next::fuchsia::WireEventPair,
828 >>::COPY_OPTIMIZATION
829 .is_enabled(),
830 )
831 };
832
833 #[inline]
834 fn from_wire(wire: crate::wire::DirEntry) -> Self {
835 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
836 }
837 }
838
839 #[derive(PartialEq, Debug)]
840 pub enum Capability {
841 Unit(crate::natural::Unit),
842
843 Handle(::fidl_next::fuchsia::zx::Handle),
844
845 Data(crate::natural::Data),
846
847 Dictionary(crate::natural::DictionaryRef),
848
849 Connector(crate::natural::Connector),
850
851 DirConnector(crate::natural::DirConnector),
852
853 Directory(
854 ::fidl_next::ClientEnd<
855 ::fidl_next_fuchsia_io::Directory,
856 ::fidl_next::fuchsia::zx::Channel,
857 >,
858 ),
859
860 DirEntry(crate::natural::DirEntry),
861
862 ConnectorRouter(
863 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
864 ),
865
866 DictionaryRouter(
867 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
868 ),
869
870 DirEntryRouter(
871 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
872 ),
873
874 DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
875
876 DirConnectorRouter(
877 ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
878 ),
879
880 UnknownOrdinal_(u64),
881 }
882
883 impl Capability {
884 pub fn is_unknown(&self) -> bool {
885 #[allow(unreachable_patterns)]
886 match self {
887 Self::UnknownOrdinal_(_) => true,
888 _ => false,
889 }
890 }
891 }
892
893 impl ::fidl_next::Encodable for Capability {
894 type Encoded = crate::wire::Capability<'static>;
895 }
896
897 unsafe impl<___E> ::fidl_next::Encode<___E> for Capability
898 where
899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
900 ___E: ::fidl_next::Encoder,
901 ___E: ::fidl_next::fuchsia::HandleEncoder,
902 {
903 #[inline]
904 fn encode(
905 self,
906 encoder: &mut ___E,
907 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
908 _: (),
909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
910 ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);
911
912 match self {
913 Self::Unit(value) => ::fidl_next::RawWireUnion::encode_as::<
914 ___E,
915 crate::natural::Unit,
916 >(value, 1, encoder, raw, ())?,
917
918 Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
919 ___E,
920 ::fidl_next::fuchsia::zx::Handle,
921 >(value, 2, encoder, raw, ())?,
922
923 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
924 ___E,
925 crate::natural::Data,
926 >(value, 3, encoder, raw, ())?,
927
928 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
929 ___E,
930 crate::natural::DictionaryRef,
931 >(value, 4, encoder, raw, ())?,
932
933 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as::<
934 ___E,
935 crate::natural::Connector,
936 >(value, 5, encoder, raw, ())?,
937
938 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
939 ___E,
940 crate::natural::DirConnector,
941 >(value, 6, encoder, raw, ())?,
942
943 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
944 ___E,
945 ::fidl_next::ClientEnd<
946 ::fidl_next_fuchsia_io::Directory,
947 ::fidl_next::fuchsia::zx::Channel,
948 >,
949 >(value, 7, encoder, raw, ())?,
950
951 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<
952 ___E,
953 crate::natural::DirEntry,
954 >(value, 8, encoder, raw, ())?,
955
956 Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
957 ___E,
958 ::fidl_next::ClientEnd<
959 crate::ConnectorRouter,
960 ::fidl_next::fuchsia::zx::Channel,
961 >,
962 >(value, 9, encoder, raw, ())?,
963
964 Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
965 ___E,
966 ::fidl_next::ClientEnd<
967 crate::DictionaryRouter,
968 ::fidl_next::fuchsia::zx::Channel,
969 >,
970 >(value, 10, encoder, raw, ())?,
971
972 Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
973 ___E,
974 ::fidl_next::ClientEnd<
975 crate::DirEntryRouter,
976 ::fidl_next::fuchsia::zx::Channel,
977 >,
978 >(value, 11, encoder, raw, ())?,
979
980 Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
981 ___E,
982 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>,
983 >(value, 12, encoder, raw, ())?,
984
985 Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
986 ___E,
987 ::fidl_next::ClientEnd<
988 crate::DirConnectorRouter,
989 ::fidl_next::fuchsia::zx::Channel,
990 >,
991 >(value, 13, encoder, raw, ())?,
992
993 Self::UnknownOrdinal_(ordinal) => {
994 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
995 }
996 }
997
998 Ok(())
999 }
1000 }
1001
1002 impl ::fidl_next::EncodableOption for Capability {
1003 type EncodedOption = crate::wire_optional::Capability<'static>;
1004 }
1005
1006 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Capability
1007 where
1008 ___E: ?Sized,
1009 Capability: ::fidl_next::Encode<___E>,
1010 {
1011 #[inline]
1012 fn encode_option(
1013 this: ::core::option::Option<Self>,
1014 encoder: &mut ___E,
1015 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1016 _: (),
1017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1018 ::fidl_next::munge!(let crate::wire_optional::Capability { raw, _phantom: _ } = &mut *out);
1019
1020 if let Some(inner) = this {
1021 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1022 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1023 } else {
1024 ::fidl_next::RawWireUnion::encode_absent(raw);
1025 }
1026
1027 Ok(())
1028 }
1029 }
1030
1031 impl<'de> ::fidl_next::FromWire<crate::wire::Capability<'de>> for Capability {
1032 #[inline]
1033 fn from_wire(wire: crate::wire::Capability<'de>) -> Self {
1034 let wire = ::core::mem::ManuallyDrop::new(wire);
1035 match wire.raw.ordinal() {
1036 1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
1037 wire.raw.get().read_unchecked::<crate::wire::Unit>()
1038 })),
1039
1040 2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
1041 wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
1042 })),
1043
1044 3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
1045 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
1046 })),
1047
1048 4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
1049 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
1050 })),
1051
1052 5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1053 wire.raw.get().read_unchecked::<crate::wire::Connector>()
1054 })),
1055
1056 6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
1057 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
1058 })),
1059
1060 7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1061 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1062 ::fidl_next_fuchsia_io::Directory,
1063 ::fidl_next::fuchsia::WireChannel,
1064 >>()
1065 })),
1066
1067 8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
1068 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
1069 })),
1070
1071 9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1072 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1073 crate::ConnectorRouter,
1074 ::fidl_next::fuchsia::WireChannel,
1075 >>()
1076 })),
1077
1078 10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
1079 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1080 crate::DictionaryRouter,
1081 ::fidl_next::fuchsia::WireChannel,
1082 >>()
1083 })),
1084
1085 11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
1086 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1087 crate::DirEntryRouter,
1088 ::fidl_next::fuchsia::WireChannel,
1089 >>()
1090 })),
1091
1092 12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
1093 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1094 })),
1095
1096 13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1097 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1098 crate::DirConnectorRouter,
1099 ::fidl_next::fuchsia::WireChannel,
1100 >>()
1101 })),
1102
1103 ord => return Self::UnknownOrdinal_(ord as u64),
1104 }
1105 }
1106 }
1107
1108 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Capability {
1109 #[inline]
1110 fn from_wire_option(
1111 wire: crate::wire_optional::Capability<'de>,
1112 ) -> ::core::option::Option<Self> {
1113 if let Some(inner) = wire.into_option() {
1114 Some(::fidl_next::FromWire::from_wire(inner))
1115 } else {
1116 None
1117 }
1118 }
1119 }
1120
1121 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
1122 #[inline]
1123 fn from_wire_option(
1124 wire: crate::wire_optional::Capability<'de>,
1125 ) -> ::core::option::Option<Self> {
1126 <
1127 Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
1128 >::from_wire_option(wire).map(Box::new)
1129 }
1130 }
1131
1132 #[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"]
1133 pub type CapabilityId = u64;
1134
1135 #[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"]
1136 pub type NewCapabilityId = u64;
1137
1138 #[derive(PartialEq, Clone, Debug)]
1139 #[repr(C)]
1140 pub struct CapabilityStoreDuplicateRequest {
1141 pub id: u64,
1142
1143 pub dest_id: u64,
1144 }
1145
1146 impl ::fidl_next::Encodable for CapabilityStoreDuplicateRequest {
1147 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1148 Self,
1149 crate::wire::CapabilityStoreDuplicateRequest,
1150 > = unsafe {
1151 ::fidl_next::CopyOptimization::enable_if(
1152 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
1153 && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1154 )
1155 };
1156
1157 type Encoded = crate::wire::CapabilityStoreDuplicateRequest;
1158 }
1159
1160 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest
1161 where
1162 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1163 {
1164 #[inline]
1165 fn encode(
1166 self,
1167 encoder_: &mut ___E,
1168 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1169 _: (),
1170 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1171 ::fidl_next::munge! {
1172 let Self::Encoded {
1173 id,
1174 dest_id,
1175
1176 } = out_;
1177 }
1178
1179 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1180
1181 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1182
1183 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
1184
1185 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1186
1187 Ok(())
1188 }
1189 }
1190
1191 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateRequest
1192 where
1193 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1194 {
1195 #[inline]
1196 fn encode_ref(
1197 &self,
1198 encoder_: &mut ___E,
1199 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1200 _: (),
1201 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1202 ::fidl_next::munge! {
1203 let Self::Encoded {
1204
1205 id,
1206 dest_id,
1207
1208 } = out_;
1209 }
1210
1211 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1212
1213 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1214
1215 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
1216
1217 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1218
1219 Ok(())
1220 }
1221 }
1222
1223 impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateRequest {
1224 type EncodedOption =
1225 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDuplicateRequest>;
1226 }
1227
1228 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateRequest
1229 where
1230 ___E: ::fidl_next::Encoder + ?Sized,
1231 CapabilityStoreDuplicateRequest: ::fidl_next::Encode<___E>,
1232 {
1233 #[inline]
1234 fn encode_option(
1235 this: ::core::option::Option<Self>,
1236 encoder: &mut ___E,
1237 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1238 _: (),
1239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1240 if let Some(inner) = this {
1241 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1242 ::fidl_next::WireBox::encode_present(out);
1243 } else {
1244 ::fidl_next::WireBox::encode_absent(out);
1245 }
1246
1247 Ok(())
1248 }
1249 }
1250
1251 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateRequest
1252 where
1253 ___E: ::fidl_next::Encoder + ?Sized,
1254 CapabilityStoreDuplicateRequest: ::fidl_next::EncodeRef<___E>,
1255 {
1256 #[inline]
1257 fn encode_option_ref(
1258 this: ::core::option::Option<&Self>,
1259 encoder: &mut ___E,
1260 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1261 _: (),
1262 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1263 if let Some(inner) = this {
1264 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1265 ::fidl_next::WireBox::encode_present(out);
1266 } else {
1267 ::fidl_next::WireBox::encode_absent(out);
1268 }
1269
1270 Ok(())
1271 }
1272 }
1273
1274 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateRequest>
1275 for CapabilityStoreDuplicateRequest
1276 {
1277 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1278 crate::wire::CapabilityStoreDuplicateRequest,
1279 Self,
1280 > = unsafe {
1281 ::fidl_next::CopyOptimization::enable_if(
1282 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1283 .is_enabled()
1284 && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1285 .is_enabled(),
1286 )
1287 };
1288
1289 #[inline]
1290 fn from_wire(wire: crate::wire::CapabilityStoreDuplicateRequest) -> Self {
1291 Self {
1292 id: ::fidl_next::FromWire::from_wire(wire.id),
1293
1294 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
1295 }
1296 }
1297 }
1298
1299 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateRequest>
1300 for CapabilityStoreDuplicateRequest
1301 {
1302 #[inline]
1303 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateRequest) -> Self {
1304 Self {
1305 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1306
1307 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
1308 }
1309 }
1310 }
1311
1312 #[derive(PartialEq, Clone, Debug)]
1313 #[repr(C)]
1314 pub struct CapabilityStoreDuplicateResponse {}
1315
1316 impl ::fidl_next::Encodable for CapabilityStoreDuplicateResponse {
1317 type Encoded = crate::wire::CapabilityStoreDuplicateResponse;
1318 }
1319
1320 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateResponse
1321 where
1322 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1323 {
1324 #[inline]
1325 fn encode(
1326 self,
1327 encoder_: &mut ___E,
1328 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1329 _: (),
1330 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1331 *out_ = ::core::mem::MaybeUninit::zeroed();
1332
1333 Ok(())
1334 }
1335 }
1336
1337 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateResponse
1338 where
1339 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1340 {
1341 #[inline]
1342 fn encode_ref(
1343 &self,
1344 encoder_: &mut ___E,
1345 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1346 _: (),
1347 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1348 ::fidl_next::munge! {
1349 let Self::Encoded {
1350
1351 _empty,
1352
1353
1354 } = out_;
1355 }
1356
1357 Ok(())
1358 }
1359 }
1360
1361 impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateResponse {
1362 type EncodedOption =
1363 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDuplicateResponse>;
1364 }
1365
1366 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateResponse
1367 where
1368 ___E: ::fidl_next::Encoder + ?Sized,
1369 CapabilityStoreDuplicateResponse: ::fidl_next::Encode<___E>,
1370 {
1371 #[inline]
1372 fn encode_option(
1373 this: ::core::option::Option<Self>,
1374 encoder: &mut ___E,
1375 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1376 _: (),
1377 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1378 if let Some(inner) = this {
1379 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1380 ::fidl_next::WireBox::encode_present(out);
1381 } else {
1382 ::fidl_next::WireBox::encode_absent(out);
1383 }
1384
1385 Ok(())
1386 }
1387 }
1388
1389 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateResponse
1390 where
1391 ___E: ::fidl_next::Encoder + ?Sized,
1392 CapabilityStoreDuplicateResponse: ::fidl_next::EncodeRef<___E>,
1393 {
1394 #[inline]
1395 fn encode_option_ref(
1396 this: ::core::option::Option<&Self>,
1397 encoder: &mut ___E,
1398 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1399 _: (),
1400 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1401 if let Some(inner) = this {
1402 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1403 ::fidl_next::WireBox::encode_present(out);
1404 } else {
1405 ::fidl_next::WireBox::encode_absent(out);
1406 }
1407
1408 Ok(())
1409 }
1410 }
1411
1412 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateResponse>
1413 for CapabilityStoreDuplicateResponse
1414 {
1415 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1416 crate::wire::CapabilityStoreDuplicateResponse,
1417 Self,
1418 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1419
1420 #[inline]
1421 fn from_wire(wire: crate::wire::CapabilityStoreDuplicateResponse) -> Self {
1422 Self {}
1423 }
1424 }
1425
1426 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateResponse>
1427 for CapabilityStoreDuplicateResponse
1428 {
1429 #[inline]
1430 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateResponse) -> Self {
1431 Self {}
1432 }
1433 }
1434
1435 #[doc = " Error returned from methods in [CapabilityStore].\n"]
1436 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1437 #[repr(u32)]
1438 pub enum CapabilityStoreError {
1439 IdNotFound = 1,
1440 IdAlreadyExists = 2,
1441 BadCapability = 3,
1442 WrongType = 4,
1443 NotDuplicatable = 5,
1444 ItemNotFound = 6,
1445 ItemAlreadyExists = 7,
1446 InvalidKey = 8,
1447 InvalidArgs = 9,
1448 UnknownOrdinal_(u32) = 10,
1449 }
1450
1451 impl ::fidl_next::Encodable for CapabilityStoreError {
1452 type Encoded = crate::wire::CapabilityStoreError;
1453 }
1454 impl ::std::convert::From<u32> for CapabilityStoreError {
1455 fn from(value: u32) -> Self {
1456 match value {
1457 1 => Self::IdNotFound,
1458 2 => Self::IdAlreadyExists,
1459 3 => Self::BadCapability,
1460 4 => Self::WrongType,
1461 5 => Self::NotDuplicatable,
1462 6 => Self::ItemNotFound,
1463 7 => Self::ItemAlreadyExists,
1464 8 => Self::InvalidKey,
1465 9 => Self::InvalidArgs,
1466
1467 _ => Self::UnknownOrdinal_(value),
1468 }
1469 }
1470 }
1471
1472 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreError
1473 where
1474 ___E: ?Sized,
1475 {
1476 #[inline]
1477 fn encode(
1478 self,
1479 encoder: &mut ___E,
1480 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1481 _: (),
1482 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1483 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
1484 }
1485 }
1486
1487 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreError
1488 where
1489 ___E: ?Sized,
1490 {
1491 #[inline]
1492 fn encode_ref(
1493 &self,
1494 encoder: &mut ___E,
1495 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1496 _: (),
1497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1498 ::fidl_next::munge!(let crate::wire::CapabilityStoreError { value } = out);
1499 let _ = value.write(::fidl_next::WireU32::from(match *self {
1500 Self::IdNotFound => 1,
1501
1502 Self::IdAlreadyExists => 2,
1503
1504 Self::BadCapability => 3,
1505
1506 Self::WrongType => 4,
1507
1508 Self::NotDuplicatable => 5,
1509
1510 Self::ItemNotFound => 6,
1511
1512 Self::ItemAlreadyExists => 7,
1513
1514 Self::InvalidKey => 8,
1515
1516 Self::InvalidArgs => 9,
1517
1518 Self::UnknownOrdinal_(value) => value,
1519 }));
1520
1521 Ok(())
1522 }
1523 }
1524
1525 impl ::core::convert::From<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1526 fn from(wire: crate::wire::CapabilityStoreError) -> Self {
1527 match u32::from(wire.value) {
1528 1 => Self::IdNotFound,
1529
1530 2 => Self::IdAlreadyExists,
1531
1532 3 => Self::BadCapability,
1533
1534 4 => Self::WrongType,
1535
1536 5 => Self::NotDuplicatable,
1537
1538 6 => Self::ItemNotFound,
1539
1540 7 => Self::ItemAlreadyExists,
1541
1542 8 => Self::InvalidKey,
1543
1544 9 => Self::InvalidArgs,
1545
1546 value => Self::UnknownOrdinal_(value),
1547 }
1548 }
1549 }
1550
1551 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1552 #[inline]
1553 fn from_wire(wire: crate::wire::CapabilityStoreError) -> Self {
1554 Self::from(wire)
1555 }
1556 }
1557
1558 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1559 #[inline]
1560 fn from_wire_ref(wire: &crate::wire::CapabilityStoreError) -> Self {
1561 Self::from(*wire)
1562 }
1563 }
1564
1565 #[derive(PartialEq, Clone, Debug)]
1566 #[repr(C)]
1567 pub struct CapabilityStoreDropRequest {
1568 pub id: u64,
1569 }
1570
1571 impl ::fidl_next::Encodable for CapabilityStoreDropRequest {
1572 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1573 Self,
1574 crate::wire::CapabilityStoreDropRequest,
1575 > = unsafe {
1576 ::fidl_next::CopyOptimization::enable_if(
1577 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1578 )
1579 };
1580
1581 type Encoded = crate::wire::CapabilityStoreDropRequest;
1582 }
1583
1584 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest
1585 where
1586 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1587 {
1588 #[inline]
1589 fn encode(
1590 self,
1591 encoder_: &mut ___E,
1592 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1593 _: (),
1594 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1595 ::fidl_next::munge! {
1596 let Self::Encoded {
1597 id,
1598
1599 } = out_;
1600 }
1601
1602 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1603
1604 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1605
1606 Ok(())
1607 }
1608 }
1609
1610 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropRequest
1611 where
1612 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1613 {
1614 #[inline]
1615 fn encode_ref(
1616 &self,
1617 encoder_: &mut ___E,
1618 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1619 _: (),
1620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1621 ::fidl_next::munge! {
1622 let Self::Encoded {
1623
1624 id,
1625
1626 } = out_;
1627 }
1628
1629 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1630
1631 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1632
1633 Ok(())
1634 }
1635 }
1636
1637 impl ::fidl_next::EncodableOption for CapabilityStoreDropRequest {
1638 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDropRequest>;
1639 }
1640
1641 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropRequest
1642 where
1643 ___E: ::fidl_next::Encoder + ?Sized,
1644 CapabilityStoreDropRequest: ::fidl_next::Encode<___E>,
1645 {
1646 #[inline]
1647 fn encode_option(
1648 this: ::core::option::Option<Self>,
1649 encoder: &mut ___E,
1650 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1651 _: (),
1652 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1653 if let Some(inner) = this {
1654 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1655 ::fidl_next::WireBox::encode_present(out);
1656 } else {
1657 ::fidl_next::WireBox::encode_absent(out);
1658 }
1659
1660 Ok(())
1661 }
1662 }
1663
1664 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropRequest
1665 where
1666 ___E: ::fidl_next::Encoder + ?Sized,
1667 CapabilityStoreDropRequest: ::fidl_next::EncodeRef<___E>,
1668 {
1669 #[inline]
1670 fn encode_option_ref(
1671 this: ::core::option::Option<&Self>,
1672 encoder: &mut ___E,
1673 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1674 _: (),
1675 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1676 if let Some(inner) = this {
1677 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1678 ::fidl_next::WireBox::encode_present(out);
1679 } else {
1680 ::fidl_next::WireBox::encode_absent(out);
1681 }
1682
1683 Ok(())
1684 }
1685 }
1686
1687 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropRequest> for CapabilityStoreDropRequest {
1688 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1689 crate::wire::CapabilityStoreDropRequest,
1690 Self,
1691 > = unsafe {
1692 ::fidl_next::CopyOptimization::enable_if(
1693 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1694 .is_enabled(),
1695 )
1696 };
1697
1698 #[inline]
1699 fn from_wire(wire: crate::wire::CapabilityStoreDropRequest) -> Self {
1700 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1701 }
1702 }
1703
1704 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropRequest>
1705 for CapabilityStoreDropRequest
1706 {
1707 #[inline]
1708 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropRequest) -> Self {
1709 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1710 }
1711 }
1712
1713 #[derive(PartialEq, Clone, Debug)]
1714 #[repr(C)]
1715 pub struct CapabilityStoreDropResponse {}
1716
1717 impl ::fidl_next::Encodable for CapabilityStoreDropResponse {
1718 type Encoded = crate::wire::CapabilityStoreDropResponse;
1719 }
1720
1721 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropResponse
1722 where
1723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1724 {
1725 #[inline]
1726 fn encode(
1727 self,
1728 encoder_: &mut ___E,
1729 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1730 _: (),
1731 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1732 *out_ = ::core::mem::MaybeUninit::zeroed();
1733
1734 Ok(())
1735 }
1736 }
1737
1738 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropResponse
1739 where
1740 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1741 {
1742 #[inline]
1743 fn encode_ref(
1744 &self,
1745 encoder_: &mut ___E,
1746 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1747 _: (),
1748 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1749 ::fidl_next::munge! {
1750 let Self::Encoded {
1751
1752 _empty,
1753
1754
1755 } = out_;
1756 }
1757
1758 Ok(())
1759 }
1760 }
1761
1762 impl ::fidl_next::EncodableOption for CapabilityStoreDropResponse {
1763 type EncodedOption =
1764 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDropResponse>;
1765 }
1766
1767 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropResponse
1768 where
1769 ___E: ::fidl_next::Encoder + ?Sized,
1770 CapabilityStoreDropResponse: ::fidl_next::Encode<___E>,
1771 {
1772 #[inline]
1773 fn encode_option(
1774 this: ::core::option::Option<Self>,
1775 encoder: &mut ___E,
1776 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1777 _: (),
1778 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1779 if let Some(inner) = this {
1780 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1781 ::fidl_next::WireBox::encode_present(out);
1782 } else {
1783 ::fidl_next::WireBox::encode_absent(out);
1784 }
1785
1786 Ok(())
1787 }
1788 }
1789
1790 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropResponse
1791 where
1792 ___E: ::fidl_next::Encoder + ?Sized,
1793 CapabilityStoreDropResponse: ::fidl_next::EncodeRef<___E>,
1794 {
1795 #[inline]
1796 fn encode_option_ref(
1797 this: ::core::option::Option<&Self>,
1798 encoder: &mut ___E,
1799 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1800 _: (),
1801 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1802 if let Some(inner) = this {
1803 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1804 ::fidl_next::WireBox::encode_present(out);
1805 } else {
1806 ::fidl_next::WireBox::encode_absent(out);
1807 }
1808
1809 Ok(())
1810 }
1811 }
1812
1813 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropResponse>
1814 for CapabilityStoreDropResponse
1815 {
1816 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1817 crate::wire::CapabilityStoreDropResponse,
1818 Self,
1819 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1820
1821 #[inline]
1822 fn from_wire(wire: crate::wire::CapabilityStoreDropResponse) -> Self {
1823 Self {}
1824 }
1825 }
1826
1827 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropResponse>
1828 for CapabilityStoreDropResponse
1829 {
1830 #[inline]
1831 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropResponse) -> Self {
1832 Self {}
1833 }
1834 }
1835
1836 #[derive(PartialEq, Clone, Debug)]
1837 #[repr(C)]
1838 pub struct CapabilityStoreExportRequest {
1839 pub id: u64,
1840 }
1841
1842 impl ::fidl_next::Encodable for CapabilityStoreExportRequest {
1843 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1844 Self,
1845 crate::wire::CapabilityStoreExportRequest,
1846 > = unsafe {
1847 ::fidl_next::CopyOptimization::enable_if(
1848 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1849 )
1850 };
1851
1852 type Encoded = crate::wire::CapabilityStoreExportRequest;
1853 }
1854
1855 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest
1856 where
1857 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1858 {
1859 #[inline]
1860 fn encode(
1861 self,
1862 encoder_: &mut ___E,
1863 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1864 _: (),
1865 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1866 ::fidl_next::munge! {
1867 let Self::Encoded {
1868 id,
1869
1870 } = out_;
1871 }
1872
1873 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1874
1875 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1876
1877 Ok(())
1878 }
1879 }
1880
1881 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreExportRequest
1882 where
1883 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1884 {
1885 #[inline]
1886 fn encode_ref(
1887 &self,
1888 encoder_: &mut ___E,
1889 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1890 _: (),
1891 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1892 ::fidl_next::munge! {
1893 let Self::Encoded {
1894
1895 id,
1896
1897 } = out_;
1898 }
1899
1900 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1901
1902 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1903
1904 Ok(())
1905 }
1906 }
1907
1908 impl ::fidl_next::EncodableOption for CapabilityStoreExportRequest {
1909 type EncodedOption =
1910 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportRequest>;
1911 }
1912
1913 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportRequest
1914 where
1915 ___E: ::fidl_next::Encoder + ?Sized,
1916 CapabilityStoreExportRequest: ::fidl_next::Encode<___E>,
1917 {
1918 #[inline]
1919 fn encode_option(
1920 this: ::core::option::Option<Self>,
1921 encoder: &mut ___E,
1922 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1923 _: (),
1924 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1925 if let Some(inner) = this {
1926 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1927 ::fidl_next::WireBox::encode_present(out);
1928 } else {
1929 ::fidl_next::WireBox::encode_absent(out);
1930 }
1931
1932 Ok(())
1933 }
1934 }
1935
1936 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreExportRequest
1937 where
1938 ___E: ::fidl_next::Encoder + ?Sized,
1939 CapabilityStoreExportRequest: ::fidl_next::EncodeRef<___E>,
1940 {
1941 #[inline]
1942 fn encode_option_ref(
1943 this: ::core::option::Option<&Self>,
1944 encoder: &mut ___E,
1945 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1946 _: (),
1947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1948 if let Some(inner) = this {
1949 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1950 ::fidl_next::WireBox::encode_present(out);
1951 } else {
1952 ::fidl_next::WireBox::encode_absent(out);
1953 }
1954
1955 Ok(())
1956 }
1957 }
1958
1959 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreExportRequest>
1960 for CapabilityStoreExportRequest
1961 {
1962 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1963 crate::wire::CapabilityStoreExportRequest,
1964 Self,
1965 > = unsafe {
1966 ::fidl_next::CopyOptimization::enable_if(
1967 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1968 .is_enabled(),
1969 )
1970 };
1971
1972 #[inline]
1973 fn from_wire(wire: crate::wire::CapabilityStoreExportRequest) -> Self {
1974 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1975 }
1976 }
1977
1978 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreExportRequest>
1979 for CapabilityStoreExportRequest
1980 {
1981 #[inline]
1982 fn from_wire_ref(wire: &crate::wire::CapabilityStoreExportRequest) -> Self {
1983 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1984 }
1985 }
1986
1987 #[derive(PartialEq, Clone, Debug)]
1988 #[repr(C)]
1989 pub struct CapabilityStoreImportResponse {}
1990
1991 impl ::fidl_next::Encodable for CapabilityStoreImportResponse {
1992 type Encoded = crate::wire::CapabilityStoreImportResponse;
1993 }
1994
1995 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportResponse
1996 where
1997 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1998 {
1999 #[inline]
2000 fn encode(
2001 self,
2002 encoder_: &mut ___E,
2003 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2004 _: (),
2005 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2006 *out_ = ::core::mem::MaybeUninit::zeroed();
2007
2008 Ok(())
2009 }
2010 }
2011
2012 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreImportResponse
2013 where
2014 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2015 {
2016 #[inline]
2017 fn encode_ref(
2018 &self,
2019 encoder_: &mut ___E,
2020 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2021 _: (),
2022 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2023 ::fidl_next::munge! {
2024 let Self::Encoded {
2025
2026 _empty,
2027
2028
2029 } = out_;
2030 }
2031
2032 Ok(())
2033 }
2034 }
2035
2036 impl ::fidl_next::EncodableOption for CapabilityStoreImportResponse {
2037 type EncodedOption =
2038 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportResponse>;
2039 }
2040
2041 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportResponse
2042 where
2043 ___E: ::fidl_next::Encoder + ?Sized,
2044 CapabilityStoreImportResponse: ::fidl_next::Encode<___E>,
2045 {
2046 #[inline]
2047 fn encode_option(
2048 this: ::core::option::Option<Self>,
2049 encoder: &mut ___E,
2050 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2051 _: (),
2052 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2053 if let Some(inner) = this {
2054 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2055 ::fidl_next::WireBox::encode_present(out);
2056 } else {
2057 ::fidl_next::WireBox::encode_absent(out);
2058 }
2059
2060 Ok(())
2061 }
2062 }
2063
2064 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreImportResponse
2065 where
2066 ___E: ::fidl_next::Encoder + ?Sized,
2067 CapabilityStoreImportResponse: ::fidl_next::EncodeRef<___E>,
2068 {
2069 #[inline]
2070 fn encode_option_ref(
2071 this: ::core::option::Option<&Self>,
2072 encoder: &mut ___E,
2073 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2074 _: (),
2075 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2076 if let Some(inner) = this {
2077 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2078 ::fidl_next::WireBox::encode_present(out);
2079 } else {
2080 ::fidl_next::WireBox::encode_absent(out);
2081 }
2082
2083 Ok(())
2084 }
2085 }
2086
2087 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreImportResponse>
2088 for CapabilityStoreImportResponse
2089 {
2090 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2091 crate::wire::CapabilityStoreImportResponse,
2092 Self,
2093 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2094
2095 #[inline]
2096 fn from_wire(wire: crate::wire::CapabilityStoreImportResponse) -> Self {
2097 Self {}
2098 }
2099 }
2100
2101 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreImportResponse>
2102 for CapabilityStoreImportResponse
2103 {
2104 #[inline]
2105 fn from_wire_ref(wire: &crate::wire::CapabilityStoreImportResponse) -> Self {
2106 Self {}
2107 }
2108 }
2109
2110 #[derive(PartialEq, Debug)]
2111 pub struct CapabilityStoreConnectorCreateRequest {
2112 pub id: u64,
2113
2114 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
2115 }
2116
2117 impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest {
2118 type Encoded = crate::wire::CapabilityStoreConnectorCreateRequest;
2119 }
2120
2121 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateRequest
2122 where
2123 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2124 ___E: ::fidl_next::fuchsia::HandleEncoder,
2125 {
2126 #[inline]
2127 fn encode(
2128 self,
2129 encoder_: &mut ___E,
2130 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2131 _: (),
2132 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2133 ::fidl_next::munge! {
2134 let Self::Encoded {
2135 id,
2136 receiver,
2137
2138 } = out_;
2139 }
2140
2141 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2142
2143 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2144
2145 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
2146
2147 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
2148
2149 Ok(())
2150 }
2151 }
2152
2153 impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateRequest {
2154 type EncodedOption =
2155 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>;
2156 }
2157
2158 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateRequest
2159 where
2160 ___E: ::fidl_next::Encoder + ?Sized,
2161 CapabilityStoreConnectorCreateRequest: ::fidl_next::Encode<___E>,
2162 {
2163 #[inline]
2164 fn encode_option(
2165 this: ::core::option::Option<Self>,
2166 encoder: &mut ___E,
2167 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2168 _: (),
2169 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2170 if let Some(inner) = this {
2171 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2172 ::fidl_next::WireBox::encode_present(out);
2173 } else {
2174 ::fidl_next::WireBox::encode_absent(out);
2175 }
2176
2177 Ok(())
2178 }
2179 }
2180
2181 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateRequest>
2182 for CapabilityStoreConnectorCreateRequest
2183 {
2184 #[inline]
2185 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateRequest) -> Self {
2186 Self {
2187 id: ::fidl_next::FromWire::from_wire(wire.id),
2188
2189 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
2190 }
2191 }
2192 }
2193
2194 #[derive(PartialEq, Clone, Debug)]
2195 #[repr(C)]
2196 pub struct CapabilityStoreConnectorCreateResponse {}
2197
2198 impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateResponse {
2199 type Encoded = crate::wire::CapabilityStoreConnectorCreateResponse;
2200 }
2201
2202 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateResponse
2203 where
2204 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2205 {
2206 #[inline]
2207 fn encode(
2208 self,
2209 encoder_: &mut ___E,
2210 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2211 _: (),
2212 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2213 *out_ = ::core::mem::MaybeUninit::zeroed();
2214
2215 Ok(())
2216 }
2217 }
2218
2219 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreConnectorCreateResponse
2220 where
2221 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2222 {
2223 #[inline]
2224 fn encode_ref(
2225 &self,
2226 encoder_: &mut ___E,
2227 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2228 _: (),
2229 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2230 ::fidl_next::munge! {
2231 let Self::Encoded {
2232
2233 _empty,
2234
2235
2236 } = out_;
2237 }
2238
2239 Ok(())
2240 }
2241 }
2242
2243 impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateResponse {
2244 type EncodedOption =
2245 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateResponse>;
2246 }
2247
2248 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateResponse
2249 where
2250 ___E: ::fidl_next::Encoder + ?Sized,
2251 CapabilityStoreConnectorCreateResponse: ::fidl_next::Encode<___E>,
2252 {
2253 #[inline]
2254 fn encode_option(
2255 this: ::core::option::Option<Self>,
2256 encoder: &mut ___E,
2257 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2258 _: (),
2259 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2260 if let Some(inner) = this {
2261 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2262 ::fidl_next::WireBox::encode_present(out);
2263 } else {
2264 ::fidl_next::WireBox::encode_absent(out);
2265 }
2266
2267 Ok(())
2268 }
2269 }
2270
2271 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreConnectorCreateResponse
2272 where
2273 ___E: ::fidl_next::Encoder + ?Sized,
2274 CapabilityStoreConnectorCreateResponse: ::fidl_next::EncodeRef<___E>,
2275 {
2276 #[inline]
2277 fn encode_option_ref(
2278 this: ::core::option::Option<&Self>,
2279 encoder: &mut ___E,
2280 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2281 _: (),
2282 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2283 if let Some(inner) = this {
2284 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2285 ::fidl_next::WireBox::encode_present(out);
2286 } else {
2287 ::fidl_next::WireBox::encode_absent(out);
2288 }
2289
2290 Ok(())
2291 }
2292 }
2293
2294 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateResponse>
2295 for CapabilityStoreConnectorCreateResponse
2296 {
2297 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2298 crate::wire::CapabilityStoreConnectorCreateResponse,
2299 Self,
2300 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2301
2302 #[inline]
2303 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
2304 Self {}
2305 }
2306 }
2307
2308 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorCreateResponse>
2309 for CapabilityStoreConnectorCreateResponse
2310 {
2311 #[inline]
2312 fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
2313 Self {}
2314 }
2315 }
2316
2317 #[derive(PartialEq, Debug)]
2318 pub struct CapabilityStoreConnectorOpenRequest {
2319 pub id: u64,
2320
2321 pub server_end: ::fidl_next::fuchsia::zx::Channel,
2322 }
2323
2324 impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest {
2325 type Encoded = crate::wire::CapabilityStoreConnectorOpenRequest;
2326 }
2327
2328 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest
2329 where
2330 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2331 ___E: ::fidl_next::fuchsia::HandleEncoder,
2332 {
2333 #[inline]
2334 fn encode(
2335 self,
2336 encoder_: &mut ___E,
2337 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2338 _: (),
2339 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2340 ::fidl_next::munge! {
2341 let Self::Encoded {
2342 id,
2343 server_end,
2344
2345 } = out_;
2346 }
2347
2348 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2349
2350 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2351
2352 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
2353
2354 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
2355
2356 Ok(())
2357 }
2358 }
2359
2360 impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenRequest {
2361 type EncodedOption =
2362 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>;
2363 }
2364
2365 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenRequest
2366 where
2367 ___E: ::fidl_next::Encoder + ?Sized,
2368 CapabilityStoreConnectorOpenRequest: ::fidl_next::Encode<___E>,
2369 {
2370 #[inline]
2371 fn encode_option(
2372 this: ::core::option::Option<Self>,
2373 encoder: &mut ___E,
2374 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2375 _: (),
2376 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2377 if let Some(inner) = this {
2378 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2379 ::fidl_next::WireBox::encode_present(out);
2380 } else {
2381 ::fidl_next::WireBox::encode_absent(out);
2382 }
2383
2384 Ok(())
2385 }
2386 }
2387
2388 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenRequest>
2389 for CapabilityStoreConnectorOpenRequest
2390 {
2391 #[inline]
2392 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenRequest) -> Self {
2393 Self {
2394 id: ::fidl_next::FromWire::from_wire(wire.id),
2395
2396 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
2397 }
2398 }
2399 }
2400
2401 #[derive(PartialEq, Clone, Debug)]
2402 #[repr(C)]
2403 pub struct CapabilityStoreConnectorOpenResponse {}
2404
2405 impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenResponse {
2406 type Encoded = crate::wire::CapabilityStoreConnectorOpenResponse;
2407 }
2408
2409 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenResponse
2410 where
2411 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2412 {
2413 #[inline]
2414 fn encode(
2415 self,
2416 encoder_: &mut ___E,
2417 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2418 _: (),
2419 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2420 *out_ = ::core::mem::MaybeUninit::zeroed();
2421
2422 Ok(())
2423 }
2424 }
2425
2426 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreConnectorOpenResponse
2427 where
2428 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2429 {
2430 #[inline]
2431 fn encode_ref(
2432 &self,
2433 encoder_: &mut ___E,
2434 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2435 _: (),
2436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2437 ::fidl_next::munge! {
2438 let Self::Encoded {
2439
2440 _empty,
2441
2442
2443 } = out_;
2444 }
2445
2446 Ok(())
2447 }
2448 }
2449
2450 impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenResponse {
2451 type EncodedOption =
2452 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenResponse>;
2453 }
2454
2455 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenResponse
2456 where
2457 ___E: ::fidl_next::Encoder + ?Sized,
2458 CapabilityStoreConnectorOpenResponse: ::fidl_next::Encode<___E>,
2459 {
2460 #[inline]
2461 fn encode_option(
2462 this: ::core::option::Option<Self>,
2463 encoder: &mut ___E,
2464 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2465 _: (),
2466 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2467 if let Some(inner) = this {
2468 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2469 ::fidl_next::WireBox::encode_present(out);
2470 } else {
2471 ::fidl_next::WireBox::encode_absent(out);
2472 }
2473
2474 Ok(())
2475 }
2476 }
2477
2478 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreConnectorOpenResponse
2479 where
2480 ___E: ::fidl_next::Encoder + ?Sized,
2481 CapabilityStoreConnectorOpenResponse: ::fidl_next::EncodeRef<___E>,
2482 {
2483 #[inline]
2484 fn encode_option_ref(
2485 this: ::core::option::Option<&Self>,
2486 encoder: &mut ___E,
2487 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2488 _: (),
2489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2490 if let Some(inner) = this {
2491 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2492 ::fidl_next::WireBox::encode_present(out);
2493 } else {
2494 ::fidl_next::WireBox::encode_absent(out);
2495 }
2496
2497 Ok(())
2498 }
2499 }
2500
2501 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenResponse>
2502 for CapabilityStoreConnectorOpenResponse
2503 {
2504 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2505 crate::wire::CapabilityStoreConnectorOpenResponse,
2506 Self,
2507 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2508
2509 #[inline]
2510 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
2511 Self {}
2512 }
2513 }
2514
2515 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorOpenResponse>
2516 for CapabilityStoreConnectorOpenResponse
2517 {
2518 #[inline]
2519 fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
2520 Self {}
2521 }
2522 }
2523
2524 #[derive(PartialEq, Clone, Debug)]
2525 #[repr(C)]
2526 pub struct CapabilityStoreDirConnectorCreateResponse {}
2527
2528 impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateResponse {
2529 type Encoded = crate::wire::CapabilityStoreDirConnectorCreateResponse;
2530 }
2531
2532 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateResponse
2533 where
2534 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2535 {
2536 #[inline]
2537 fn encode(
2538 self,
2539 encoder_: &mut ___E,
2540 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2541 _: (),
2542 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2543 *out_ = ::core::mem::MaybeUninit::zeroed();
2544
2545 Ok(())
2546 }
2547 }
2548
2549 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDirConnectorCreateResponse
2550 where
2551 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2552 {
2553 #[inline]
2554 fn encode_ref(
2555 &self,
2556 encoder_: &mut ___E,
2557 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2558 _: (),
2559 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2560 ::fidl_next::munge! {
2561 let Self::Encoded {
2562
2563 _empty,
2564
2565
2566 } = out_;
2567 }
2568
2569 Ok(())
2570 }
2571 }
2572
2573 impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateResponse {
2574 type EncodedOption =
2575 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateResponse>;
2576 }
2577
2578 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateResponse
2579 where
2580 ___E: ::fidl_next::Encoder + ?Sized,
2581 CapabilityStoreDirConnectorCreateResponse: ::fidl_next::Encode<___E>,
2582 {
2583 #[inline]
2584 fn encode_option(
2585 this: ::core::option::Option<Self>,
2586 encoder: &mut ___E,
2587 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 if let Some(inner) = this {
2591 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2592 ::fidl_next::WireBox::encode_present(out);
2593 } else {
2594 ::fidl_next::WireBox::encode_absent(out);
2595 }
2596
2597 Ok(())
2598 }
2599 }
2600
2601 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDirConnectorCreateResponse
2602 where
2603 ___E: ::fidl_next::Encoder + ?Sized,
2604 CapabilityStoreDirConnectorCreateResponse: ::fidl_next::EncodeRef<___E>,
2605 {
2606 #[inline]
2607 fn encode_option_ref(
2608 this: ::core::option::Option<&Self>,
2609 encoder: &mut ___E,
2610 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2611 _: (),
2612 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2613 if let Some(inner) = this {
2614 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2615 ::fidl_next::WireBox::encode_present(out);
2616 } else {
2617 ::fidl_next::WireBox::encode_absent(out);
2618 }
2619
2620 Ok(())
2621 }
2622 }
2623
2624 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateResponse>
2625 for CapabilityStoreDirConnectorCreateResponse
2626 {
2627 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2628 crate::wire::CapabilityStoreDirConnectorCreateResponse,
2629 Self,
2630 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2631
2632 #[inline]
2633 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
2634 Self {}
2635 }
2636 }
2637
2638 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorCreateResponse>
2639 for CapabilityStoreDirConnectorCreateResponse
2640 {
2641 #[inline]
2642 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
2643 Self {}
2644 }
2645 }
2646
2647 #[derive(PartialEq, Clone, Debug)]
2648 #[repr(C)]
2649 pub struct CapabilityStoreDirConnectorOpenResponse {}
2650
2651 impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenResponse {
2652 type Encoded = crate::wire::CapabilityStoreDirConnectorOpenResponse;
2653 }
2654
2655 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenResponse
2656 where
2657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2658 {
2659 #[inline]
2660 fn encode(
2661 self,
2662 encoder_: &mut ___E,
2663 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2664 _: (),
2665 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2666 *out_ = ::core::mem::MaybeUninit::zeroed();
2667
2668 Ok(())
2669 }
2670 }
2671
2672 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDirConnectorOpenResponse
2673 where
2674 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2675 {
2676 #[inline]
2677 fn encode_ref(
2678 &self,
2679 encoder_: &mut ___E,
2680 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2681 _: (),
2682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2683 ::fidl_next::munge! {
2684 let Self::Encoded {
2685
2686 _empty,
2687
2688
2689 } = out_;
2690 }
2691
2692 Ok(())
2693 }
2694 }
2695
2696 impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenResponse {
2697 type EncodedOption =
2698 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenResponse>;
2699 }
2700
2701 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenResponse
2702 where
2703 ___E: ::fidl_next::Encoder + ?Sized,
2704 CapabilityStoreDirConnectorOpenResponse: ::fidl_next::Encode<___E>,
2705 {
2706 #[inline]
2707 fn encode_option(
2708 this: ::core::option::Option<Self>,
2709 encoder: &mut ___E,
2710 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2711 _: (),
2712 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2713 if let Some(inner) = this {
2714 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2715 ::fidl_next::WireBox::encode_present(out);
2716 } else {
2717 ::fidl_next::WireBox::encode_absent(out);
2718 }
2719
2720 Ok(())
2721 }
2722 }
2723
2724 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDirConnectorOpenResponse
2725 where
2726 ___E: ::fidl_next::Encoder + ?Sized,
2727 CapabilityStoreDirConnectorOpenResponse: ::fidl_next::EncodeRef<___E>,
2728 {
2729 #[inline]
2730 fn encode_option_ref(
2731 this: ::core::option::Option<&Self>,
2732 encoder: &mut ___E,
2733 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2734 _: (),
2735 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2736 if let Some(inner) = this {
2737 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2738 ::fidl_next::WireBox::encode_present(out);
2739 } else {
2740 ::fidl_next::WireBox::encode_absent(out);
2741 }
2742
2743 Ok(())
2744 }
2745 }
2746
2747 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2748 for CapabilityStoreDirConnectorOpenResponse
2749 {
2750 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2751 crate::wire::CapabilityStoreDirConnectorOpenResponse,
2752 Self,
2753 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2754
2755 #[inline]
2756 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2757 Self {}
2758 }
2759 }
2760
2761 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2762 for CapabilityStoreDirConnectorOpenResponse
2763 {
2764 #[inline]
2765 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2766 Self {}
2767 }
2768 }
2769
2770 #[derive(PartialEq, Clone, Debug)]
2771 #[repr(C)]
2772 pub struct CapabilityStoreDictionaryCreateRequest {
2773 pub id: u64,
2774 }
2775
2776 impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest {
2777 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2778 Self,
2779 crate::wire::CapabilityStoreDictionaryCreateRequest,
2780 > = unsafe {
2781 ::fidl_next::CopyOptimization::enable_if(
2782 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2783 )
2784 };
2785
2786 type Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest;
2787 }
2788
2789 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest
2790 where
2791 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2792 {
2793 #[inline]
2794 fn encode(
2795 self,
2796 encoder_: &mut ___E,
2797 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2798 _: (),
2799 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2800 ::fidl_next::munge! {
2801 let Self::Encoded {
2802 id,
2803
2804 } = out_;
2805 }
2806
2807 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2808
2809 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2810
2811 Ok(())
2812 }
2813 }
2814
2815 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateRequest
2816 where
2817 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2818 {
2819 #[inline]
2820 fn encode_ref(
2821 &self,
2822 encoder_: &mut ___E,
2823 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2824 _: (),
2825 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2826 ::fidl_next::munge! {
2827 let Self::Encoded {
2828
2829 id,
2830
2831 } = out_;
2832 }
2833
2834 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
2835
2836 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2837
2838 Ok(())
2839 }
2840 }
2841
2842 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateRequest {
2843 type EncodedOption =
2844 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>;
2845 }
2846
2847 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateRequest
2848 where
2849 ___E: ::fidl_next::Encoder + ?Sized,
2850 CapabilityStoreDictionaryCreateRequest: ::fidl_next::Encode<___E>,
2851 {
2852 #[inline]
2853 fn encode_option(
2854 this: ::core::option::Option<Self>,
2855 encoder: &mut ___E,
2856 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2857 _: (),
2858 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2859 if let Some(inner) = this {
2860 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2861 ::fidl_next::WireBox::encode_present(out);
2862 } else {
2863 ::fidl_next::WireBox::encode_absent(out);
2864 }
2865
2866 Ok(())
2867 }
2868 }
2869
2870 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateRequest
2871 where
2872 ___E: ::fidl_next::Encoder + ?Sized,
2873 CapabilityStoreDictionaryCreateRequest: ::fidl_next::EncodeRef<___E>,
2874 {
2875 #[inline]
2876 fn encode_option_ref(
2877 this: ::core::option::Option<&Self>,
2878 encoder: &mut ___E,
2879 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2880 _: (),
2881 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2882 if let Some(inner) = this {
2883 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2884 ::fidl_next::WireBox::encode_present(out);
2885 } else {
2886 ::fidl_next::WireBox::encode_absent(out);
2887 }
2888
2889 Ok(())
2890 }
2891 }
2892
2893 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateRequest>
2894 for CapabilityStoreDictionaryCreateRequest
2895 {
2896 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2897 crate::wire::CapabilityStoreDictionaryCreateRequest,
2898 Self,
2899 > = unsafe {
2900 ::fidl_next::CopyOptimization::enable_if(
2901 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2902 .is_enabled(),
2903 )
2904 };
2905
2906 #[inline]
2907 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2908 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2909 }
2910 }
2911
2912 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateRequest>
2913 for CapabilityStoreDictionaryCreateRequest
2914 {
2915 #[inline]
2916 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2917 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2918 }
2919 }
2920
2921 #[derive(PartialEq, Clone, Debug)]
2922 #[repr(C)]
2923 pub struct CapabilityStoreDictionaryCreateResponse {}
2924
2925 impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateResponse {
2926 type Encoded = crate::wire::CapabilityStoreDictionaryCreateResponse;
2927 }
2928
2929 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateResponse
2930 where
2931 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2932 {
2933 #[inline]
2934 fn encode(
2935 self,
2936 encoder_: &mut ___E,
2937 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2938 _: (),
2939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940 *out_ = ::core::mem::MaybeUninit::zeroed();
2941
2942 Ok(())
2943 }
2944 }
2945
2946 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateResponse
2947 where
2948 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2949 {
2950 #[inline]
2951 fn encode_ref(
2952 &self,
2953 encoder_: &mut ___E,
2954 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2955 _: (),
2956 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2957 ::fidl_next::munge! {
2958 let Self::Encoded {
2959
2960 _empty,
2961
2962
2963 } = out_;
2964 }
2965
2966 Ok(())
2967 }
2968 }
2969
2970 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateResponse {
2971 type EncodedOption =
2972 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCreateResponse>;
2973 }
2974
2975 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateResponse
2976 where
2977 ___E: ::fidl_next::Encoder + ?Sized,
2978 CapabilityStoreDictionaryCreateResponse: ::fidl_next::Encode<___E>,
2979 {
2980 #[inline]
2981 fn encode_option(
2982 this: ::core::option::Option<Self>,
2983 encoder: &mut ___E,
2984 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2985 _: (),
2986 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2987 if let Some(inner) = this {
2988 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2989 ::fidl_next::WireBox::encode_present(out);
2990 } else {
2991 ::fidl_next::WireBox::encode_absent(out);
2992 }
2993
2994 Ok(())
2995 }
2996 }
2997
2998 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateResponse
2999 where
3000 ___E: ::fidl_next::Encoder + ?Sized,
3001 CapabilityStoreDictionaryCreateResponse: ::fidl_next::EncodeRef<___E>,
3002 {
3003 #[inline]
3004 fn encode_option_ref(
3005 this: ::core::option::Option<&Self>,
3006 encoder: &mut ___E,
3007 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3008 _: (),
3009 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3010 if let Some(inner) = this {
3011 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3012 ::fidl_next::WireBox::encode_present(out);
3013 } else {
3014 ::fidl_next::WireBox::encode_absent(out);
3015 }
3016
3017 Ok(())
3018 }
3019 }
3020
3021 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateResponse>
3022 for CapabilityStoreDictionaryCreateResponse
3023 {
3024 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3025 crate::wire::CapabilityStoreDictionaryCreateResponse,
3026 Self,
3027 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3028
3029 #[inline]
3030 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
3031 Self {}
3032 }
3033 }
3034
3035 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateResponse>
3036 for CapabilityStoreDictionaryCreateResponse
3037 {
3038 #[inline]
3039 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
3040 Self {}
3041 }
3042 }
3043
3044 #[derive(PartialEq, Debug)]
3045 pub struct CapabilityStoreDictionaryLegacyImportRequest {
3046 pub id: u64,
3047
3048 pub client_end: ::fidl_next::fuchsia::zx::Channel,
3049 }
3050
3051 impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest {
3052 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
3053 }
3054
3055 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportRequest
3056 where
3057 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3058 ___E: ::fidl_next::fuchsia::HandleEncoder,
3059 {
3060 #[inline]
3061 fn encode(
3062 self,
3063 encoder_: &mut ___E,
3064 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067 ::fidl_next::munge! {
3068 let Self::Encoded {
3069 id,
3070 client_end,
3071
3072 } = out_;
3073 }
3074
3075 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3076
3077 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3078
3079 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
3080
3081 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
3082
3083 Ok(())
3084 }
3085 }
3086
3087 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportRequest {
3088 type EncodedOption = ::fidl_next::WireBox<
3089 'static,
3090 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
3091 >;
3092 }
3093
3094 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportRequest
3095 where
3096 ___E: ::fidl_next::Encoder + ?Sized,
3097 CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Encode<___E>,
3098 {
3099 #[inline]
3100 fn encode_option(
3101 this: ::core::option::Option<Self>,
3102 encoder: &mut ___E,
3103 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3104 _: (),
3105 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3106 if let Some(inner) = this {
3107 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3108 ::fidl_next::WireBox::encode_present(out);
3109 } else {
3110 ::fidl_next::WireBox::encode_absent(out);
3111 }
3112
3113 Ok(())
3114 }
3115 }
3116
3117 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
3118 for CapabilityStoreDictionaryLegacyImportRequest
3119 {
3120 #[inline]
3121 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
3122 Self {
3123 id: ::fidl_next::FromWire::from_wire(wire.id),
3124
3125 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
3126 }
3127 }
3128 }
3129
3130 #[derive(PartialEq, Clone, Debug)]
3131 #[repr(C)]
3132 pub struct CapabilityStoreDictionaryLegacyImportResponse {}
3133
3134 impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportResponse {
3135 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportResponse;
3136 }
3137
3138 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportResponse
3139 where
3140 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3141 {
3142 #[inline]
3143 fn encode(
3144 self,
3145 encoder_: &mut ___E,
3146 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3147 _: (),
3148 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3149 *out_ = ::core::mem::MaybeUninit::zeroed();
3150
3151 Ok(())
3152 }
3153 }
3154
3155 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryLegacyImportResponse
3156 where
3157 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3158 {
3159 #[inline]
3160 fn encode_ref(
3161 &self,
3162 encoder_: &mut ___E,
3163 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3164 _: (),
3165 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3166 ::fidl_next::munge! {
3167 let Self::Encoded {
3168
3169 _empty,
3170
3171
3172 } = out_;
3173 }
3174
3175 Ok(())
3176 }
3177 }
3178
3179 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportResponse {
3180 type EncodedOption = ::fidl_next::WireBox<
3181 'static,
3182 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3183 >;
3184 }
3185
3186 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportResponse
3187 where
3188 ___E: ::fidl_next::Encoder + ?Sized,
3189 CapabilityStoreDictionaryLegacyImportResponse: ::fidl_next::Encode<___E>,
3190 {
3191 #[inline]
3192 fn encode_option(
3193 this: ::core::option::Option<Self>,
3194 encoder: &mut ___E,
3195 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3196 _: (),
3197 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3198 if let Some(inner) = this {
3199 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3200 ::fidl_next::WireBox::encode_present(out);
3201 } else {
3202 ::fidl_next::WireBox::encode_absent(out);
3203 }
3204
3205 Ok(())
3206 }
3207 }
3208
3209 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E>
3210 for CapabilityStoreDictionaryLegacyImportResponse
3211 where
3212 ___E: ::fidl_next::Encoder + ?Sized,
3213 CapabilityStoreDictionaryLegacyImportResponse: ::fidl_next::EncodeRef<___E>,
3214 {
3215 #[inline]
3216 fn encode_option_ref(
3217 this: ::core::option::Option<&Self>,
3218 encoder: &mut ___E,
3219 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3220 _: (),
3221 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3222 if let Some(inner) = this {
3223 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3224 ::fidl_next::WireBox::encode_present(out);
3225 } else {
3226 ::fidl_next::WireBox::encode_absent(out);
3227 }
3228
3229 Ok(())
3230 }
3231 }
3232
3233 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
3234 for CapabilityStoreDictionaryLegacyImportResponse
3235 {
3236 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3237 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3238 Self,
3239 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3240
3241 #[inline]
3242 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportResponse) -> Self {
3243 Self {}
3244 }
3245 }
3246
3247 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
3248 for CapabilityStoreDictionaryLegacyImportResponse
3249 {
3250 #[inline]
3251 fn from_wire_ref(
3252 wire: &crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3253 ) -> Self {
3254 Self {}
3255 }
3256 }
3257
3258 #[derive(PartialEq, Debug)]
3259 pub struct CapabilityStoreDictionaryLegacyExportRequest {
3260 pub id: u64,
3261
3262 pub server_end: ::fidl_next::fuchsia::zx::Channel,
3263 }
3264
3265 impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest {
3266 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
3267 }
3268
3269 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportRequest
3270 where
3271 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3272 ___E: ::fidl_next::fuchsia::HandleEncoder,
3273 {
3274 #[inline]
3275 fn encode(
3276 self,
3277 encoder_: &mut ___E,
3278 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3279 _: (),
3280 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3281 ::fidl_next::munge! {
3282 let Self::Encoded {
3283 id,
3284 server_end,
3285
3286 } = out_;
3287 }
3288
3289 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3290
3291 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3292
3293 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
3294
3295 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
3296
3297 Ok(())
3298 }
3299 }
3300
3301 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportRequest {
3302 type EncodedOption = ::fidl_next::WireBox<
3303 'static,
3304 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
3305 >;
3306 }
3307
3308 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportRequest
3309 where
3310 ___E: ::fidl_next::Encoder + ?Sized,
3311 CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Encode<___E>,
3312 {
3313 #[inline]
3314 fn encode_option(
3315 this: ::core::option::Option<Self>,
3316 encoder: &mut ___E,
3317 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3318 _: (),
3319 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3320 if let Some(inner) = this {
3321 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3322 ::fidl_next::WireBox::encode_present(out);
3323 } else {
3324 ::fidl_next::WireBox::encode_absent(out);
3325 }
3326
3327 Ok(())
3328 }
3329 }
3330
3331 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
3332 for CapabilityStoreDictionaryLegacyExportRequest
3333 {
3334 #[inline]
3335 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
3336 Self {
3337 id: ::fidl_next::FromWire::from_wire(wire.id),
3338
3339 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3340 }
3341 }
3342 }
3343
3344 #[derive(PartialEq, Clone, Debug)]
3345 #[repr(C)]
3346 pub struct CapabilityStoreDictionaryLegacyExportResponse {}
3347
3348 impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportResponse {
3349 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportResponse;
3350 }
3351
3352 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportResponse
3353 where
3354 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3355 {
3356 #[inline]
3357 fn encode(
3358 self,
3359 encoder_: &mut ___E,
3360 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3361 _: (),
3362 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3363 *out_ = ::core::mem::MaybeUninit::zeroed();
3364
3365 Ok(())
3366 }
3367 }
3368
3369 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryLegacyExportResponse
3370 where
3371 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3372 {
3373 #[inline]
3374 fn encode_ref(
3375 &self,
3376 encoder_: &mut ___E,
3377 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3378 _: (),
3379 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3380 ::fidl_next::munge! {
3381 let Self::Encoded {
3382
3383 _empty,
3384
3385
3386 } = out_;
3387 }
3388
3389 Ok(())
3390 }
3391 }
3392
3393 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportResponse {
3394 type EncodedOption = ::fidl_next::WireBox<
3395 'static,
3396 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3397 >;
3398 }
3399
3400 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportResponse
3401 where
3402 ___E: ::fidl_next::Encoder + ?Sized,
3403 CapabilityStoreDictionaryLegacyExportResponse: ::fidl_next::Encode<___E>,
3404 {
3405 #[inline]
3406 fn encode_option(
3407 this: ::core::option::Option<Self>,
3408 encoder: &mut ___E,
3409 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3410 _: (),
3411 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3412 if let Some(inner) = this {
3413 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3414 ::fidl_next::WireBox::encode_present(out);
3415 } else {
3416 ::fidl_next::WireBox::encode_absent(out);
3417 }
3418
3419 Ok(())
3420 }
3421 }
3422
3423 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E>
3424 for CapabilityStoreDictionaryLegacyExportResponse
3425 where
3426 ___E: ::fidl_next::Encoder + ?Sized,
3427 CapabilityStoreDictionaryLegacyExportResponse: ::fidl_next::EncodeRef<___E>,
3428 {
3429 #[inline]
3430 fn encode_option_ref(
3431 this: ::core::option::Option<&Self>,
3432 encoder: &mut ___E,
3433 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3434 _: (),
3435 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3436 if let Some(inner) = this {
3437 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3438 ::fidl_next::WireBox::encode_present(out);
3439 } else {
3440 ::fidl_next::WireBox::encode_absent(out);
3441 }
3442
3443 Ok(())
3444 }
3445 }
3446
3447 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
3448 for CapabilityStoreDictionaryLegacyExportResponse
3449 {
3450 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3451 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3452 Self,
3453 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3454
3455 #[inline]
3456 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportResponse) -> Self {
3457 Self {}
3458 }
3459 }
3460
3461 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
3462 for CapabilityStoreDictionaryLegacyExportResponse
3463 {
3464 #[inline]
3465 fn from_wire_ref(
3466 wire: &crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3467 ) -> Self {
3468 Self {}
3469 }
3470 }
3471
3472 #[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
3473 pub type DictionaryKey = ::std::string::String;
3474
3475 #[doc = " A key-value pair in a [`DictionaryRef`].\n"]
3476 #[derive(PartialEq, Clone, Debug)]
3477 pub struct DictionaryItem {
3478 pub key: ::std::string::String,
3479
3480 pub value: u64,
3481 }
3482
3483 impl ::fidl_next::Encodable for DictionaryItem {
3484 type Encoded = crate::wire::DictionaryItem<'static>;
3485 }
3486
3487 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryItem
3488 where
3489 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3490 ___E: ::fidl_next::Encoder,
3491 {
3492 #[inline]
3493 fn encode(
3494 self,
3495 encoder_: &mut ___E,
3496 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3497 _: (),
3498 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3499 ::fidl_next::munge! {
3500 let Self::Encoded {
3501 key,
3502 value,
3503
3504 } = out_;
3505 }
3506
3507 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3508
3509 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3510 ::fidl_next::Constrained::validate(_field, 255)?;
3511
3512 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
3513
3514 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
3515
3516 Ok(())
3517 }
3518 }
3519
3520 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryItem
3521 where
3522 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3523 ___E: ::fidl_next::Encoder,
3524 {
3525 #[inline]
3526 fn encode_ref(
3527 &self,
3528 encoder_: &mut ___E,
3529 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3530 _: (),
3531 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3532 ::fidl_next::munge! {
3533 let Self::Encoded {
3534
3535 key,
3536 value,
3537
3538 } = out_;
3539 }
3540
3541 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
3542
3543 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3544 ::fidl_next::Constrained::validate(_field, 255)?;
3545
3546 ::fidl_next::EncodeRef::encode_ref(&self.value, encoder_, value, ())?;
3547
3548 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
3549
3550 Ok(())
3551 }
3552 }
3553
3554 impl ::fidl_next::EncodableOption for DictionaryItem {
3555 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DictionaryItem<'static>>;
3556 }
3557
3558 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryItem
3559 where
3560 ___E: ::fidl_next::Encoder + ?Sized,
3561 DictionaryItem: ::fidl_next::Encode<___E>,
3562 {
3563 #[inline]
3564 fn encode_option(
3565 this: ::core::option::Option<Self>,
3566 encoder: &mut ___E,
3567 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3568 _: (),
3569 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3570 if let Some(inner) = this {
3571 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3572 ::fidl_next::WireBox::encode_present(out);
3573 } else {
3574 ::fidl_next::WireBox::encode_absent(out);
3575 }
3576
3577 Ok(())
3578 }
3579 }
3580
3581 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryItem
3582 where
3583 ___E: ::fidl_next::Encoder + ?Sized,
3584 DictionaryItem: ::fidl_next::EncodeRef<___E>,
3585 {
3586 #[inline]
3587 fn encode_option_ref(
3588 this: ::core::option::Option<&Self>,
3589 encoder: &mut ___E,
3590 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3591 _: (),
3592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3593 if let Some(inner) = this {
3594 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3595 ::fidl_next::WireBox::encode_present(out);
3596 } else {
3597 ::fidl_next::WireBox::encode_absent(out);
3598 }
3599
3600 Ok(())
3601 }
3602 }
3603
3604 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryItem<'de>> for DictionaryItem {
3605 #[inline]
3606 fn from_wire(wire: crate::wire::DictionaryItem<'de>) -> Self {
3607 Self {
3608 key: ::fidl_next::FromWire::from_wire(wire.key),
3609
3610 value: ::fidl_next::FromWire::from_wire(wire.value),
3611 }
3612 }
3613 }
3614
3615 impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryItem<'de>> for DictionaryItem {
3616 #[inline]
3617 fn from_wire_ref(wire: &crate::wire::DictionaryItem<'de>) -> Self {
3618 Self {
3619 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3620
3621 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
3622 }
3623 }
3624 }
3625
3626 #[derive(PartialEq, Clone, Debug)]
3627 pub struct CapabilityStoreDictionaryInsertRequest {
3628 pub id: u64,
3629
3630 pub item: crate::natural::DictionaryItem,
3631 }
3632
3633 impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest {
3634 type Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
3635 }
3636
3637 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertRequest
3638 where
3639 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3640 ___E: ::fidl_next::Encoder,
3641 {
3642 #[inline]
3643 fn encode(
3644 self,
3645 encoder_: &mut ___E,
3646 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3647 _: (),
3648 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3649 ::fidl_next::munge! {
3650 let Self::Encoded {
3651 id,
3652 item,
3653
3654 } = out_;
3655 }
3656
3657 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3658
3659 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3660
3661 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
3662
3663 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
3664
3665 Ok(())
3666 }
3667 }
3668
3669 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertRequest
3670 where
3671 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3672 ___E: ::fidl_next::Encoder,
3673 {
3674 #[inline]
3675 fn encode_ref(
3676 &self,
3677 encoder_: &mut ___E,
3678 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3679 _: (),
3680 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3681 ::fidl_next::munge! {
3682 let Self::Encoded {
3683
3684 id,
3685 item,
3686
3687 } = out_;
3688 }
3689
3690 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
3691
3692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3693
3694 ::fidl_next::EncodeRef::encode_ref(&self.item, encoder_, item, ())?;
3695
3696 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
3697
3698 Ok(())
3699 }
3700 }
3701
3702 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertRequest {
3703 type EncodedOption = ::fidl_next::WireBox<
3704 'static,
3705 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3706 >;
3707 }
3708
3709 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertRequest
3710 where
3711 ___E: ::fidl_next::Encoder + ?Sized,
3712 CapabilityStoreDictionaryInsertRequest: ::fidl_next::Encode<___E>,
3713 {
3714 #[inline]
3715 fn encode_option(
3716 this: ::core::option::Option<Self>,
3717 encoder: &mut ___E,
3718 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3719 _: (),
3720 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3721 if let Some(inner) = this {
3722 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3723 ::fidl_next::WireBox::encode_present(out);
3724 } else {
3725 ::fidl_next::WireBox::encode_absent(out);
3726 }
3727
3728 Ok(())
3729 }
3730 }
3731
3732 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertRequest
3733 where
3734 ___E: ::fidl_next::Encoder + ?Sized,
3735 CapabilityStoreDictionaryInsertRequest: ::fidl_next::EncodeRef<___E>,
3736 {
3737 #[inline]
3738 fn encode_option_ref(
3739 this: ::core::option::Option<&Self>,
3740 encoder: &mut ___E,
3741 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3742 _: (),
3743 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3744 if let Some(inner) = this {
3745 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3746 ::fidl_next::WireBox::encode_present(out);
3747 } else {
3748 ::fidl_next::WireBox::encode_absent(out);
3749 }
3750
3751 Ok(())
3752 }
3753 }
3754
3755 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3756 for CapabilityStoreDictionaryInsertRequest
3757 {
3758 #[inline]
3759 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3760 Self {
3761 id: ::fidl_next::FromWire::from_wire(wire.id),
3762
3763 item: ::fidl_next::FromWire::from_wire(wire.item),
3764 }
3765 }
3766 }
3767
3768 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3769 for CapabilityStoreDictionaryInsertRequest
3770 {
3771 #[inline]
3772 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3773 Self {
3774 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
3775
3776 item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
3777 }
3778 }
3779 }
3780
3781 #[derive(PartialEq, Clone, Debug)]
3782 #[repr(C)]
3783 pub struct CapabilityStoreDictionaryInsertResponse {}
3784
3785 impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertResponse {
3786 type Encoded = crate::wire::CapabilityStoreDictionaryInsertResponse;
3787 }
3788
3789 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertResponse
3790 where
3791 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3792 {
3793 #[inline]
3794 fn encode(
3795 self,
3796 encoder_: &mut ___E,
3797 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3798 _: (),
3799 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3800 *out_ = ::core::mem::MaybeUninit::zeroed();
3801
3802 Ok(())
3803 }
3804 }
3805
3806 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertResponse
3807 where
3808 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3809 {
3810 #[inline]
3811 fn encode_ref(
3812 &self,
3813 encoder_: &mut ___E,
3814 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3815 _: (),
3816 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3817 ::fidl_next::munge! {
3818 let Self::Encoded {
3819
3820 _empty,
3821
3822
3823 } = out_;
3824 }
3825
3826 Ok(())
3827 }
3828 }
3829
3830 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertResponse {
3831 type EncodedOption =
3832 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryInsertResponse>;
3833 }
3834
3835 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertResponse
3836 where
3837 ___E: ::fidl_next::Encoder + ?Sized,
3838 CapabilityStoreDictionaryInsertResponse: ::fidl_next::Encode<___E>,
3839 {
3840 #[inline]
3841 fn encode_option(
3842 this: ::core::option::Option<Self>,
3843 encoder: &mut ___E,
3844 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3845 _: (),
3846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3847 if let Some(inner) = this {
3848 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3849 ::fidl_next::WireBox::encode_present(out);
3850 } else {
3851 ::fidl_next::WireBox::encode_absent(out);
3852 }
3853
3854 Ok(())
3855 }
3856 }
3857
3858 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertResponse
3859 where
3860 ___E: ::fidl_next::Encoder + ?Sized,
3861 CapabilityStoreDictionaryInsertResponse: ::fidl_next::EncodeRef<___E>,
3862 {
3863 #[inline]
3864 fn encode_option_ref(
3865 this: ::core::option::Option<&Self>,
3866 encoder: &mut ___E,
3867 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3868 _: (),
3869 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3870 if let Some(inner) = this {
3871 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3872 ::fidl_next::WireBox::encode_present(out);
3873 } else {
3874 ::fidl_next::WireBox::encode_absent(out);
3875 }
3876
3877 Ok(())
3878 }
3879 }
3880
3881 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertResponse>
3882 for CapabilityStoreDictionaryInsertResponse
3883 {
3884 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3885 crate::wire::CapabilityStoreDictionaryInsertResponse,
3886 Self,
3887 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3888
3889 #[inline]
3890 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3891 Self {}
3892 }
3893 }
3894
3895 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertResponse>
3896 for CapabilityStoreDictionaryInsertResponse
3897 {
3898 #[inline]
3899 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3900 Self {}
3901 }
3902 }
3903
3904 #[derive(PartialEq, Clone, Debug)]
3905 pub struct CapabilityStoreDictionaryGetRequest {
3906 pub id: u64,
3907
3908 pub key: ::std::string::String,
3909
3910 pub dest_id: u64,
3911 }
3912
3913 impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest {
3914 type Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
3915 }
3916
3917 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetRequest
3918 where
3919 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3920 ___E: ::fidl_next::Encoder,
3921 {
3922 #[inline]
3923 fn encode(
3924 self,
3925 encoder_: &mut ___E,
3926 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3927 _: (),
3928 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3929 ::fidl_next::munge! {
3930 let Self::Encoded {
3931 id,
3932 key,
3933 dest_id,
3934
3935 } = out_;
3936 }
3937
3938 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3939
3940 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3941
3942 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3943
3944 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3945 ::fidl_next::Constrained::validate(_field, 255)?;
3946
3947 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
3948
3949 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3950
3951 Ok(())
3952 }
3953 }
3954
3955 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetRequest
3956 where
3957 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3958 ___E: ::fidl_next::Encoder,
3959 {
3960 #[inline]
3961 fn encode_ref(
3962 &self,
3963 encoder_: &mut ___E,
3964 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3965 _: (),
3966 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3967 ::fidl_next::munge! {
3968 let Self::Encoded {
3969
3970 id,
3971 key,
3972 dest_id,
3973
3974 } = out_;
3975 }
3976
3977 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
3978
3979 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3980
3981 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
3982
3983 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3984 ::fidl_next::Constrained::validate(_field, 255)?;
3985
3986 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
3987
3988 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3989
3990 Ok(())
3991 }
3992 }
3993
3994 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetRequest {
3995 type EncodedOption = ::fidl_next::WireBox<
3996 'static,
3997 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3998 >;
3999 }
4000
4001 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetRequest
4002 where
4003 ___E: ::fidl_next::Encoder + ?Sized,
4004 CapabilityStoreDictionaryGetRequest: ::fidl_next::Encode<___E>,
4005 {
4006 #[inline]
4007 fn encode_option(
4008 this: ::core::option::Option<Self>,
4009 encoder: &mut ___E,
4010 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4011 _: (),
4012 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4013 if let Some(inner) = this {
4014 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4015 ::fidl_next::WireBox::encode_present(out);
4016 } else {
4017 ::fidl_next::WireBox::encode_absent(out);
4018 }
4019
4020 Ok(())
4021 }
4022 }
4023
4024 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetRequest
4025 where
4026 ___E: ::fidl_next::Encoder + ?Sized,
4027 CapabilityStoreDictionaryGetRequest: ::fidl_next::EncodeRef<___E>,
4028 {
4029 #[inline]
4030 fn encode_option_ref(
4031 this: ::core::option::Option<&Self>,
4032 encoder: &mut ___E,
4033 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4034 _: (),
4035 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4036 if let Some(inner) = this {
4037 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4038 ::fidl_next::WireBox::encode_present(out);
4039 } else {
4040 ::fidl_next::WireBox::encode_absent(out);
4041 }
4042
4043 Ok(())
4044 }
4045 }
4046
4047 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
4048 for CapabilityStoreDictionaryGetRequest
4049 {
4050 #[inline]
4051 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
4052 Self {
4053 id: ::fidl_next::FromWire::from_wire(wire.id),
4054
4055 key: ::fidl_next::FromWire::from_wire(wire.key),
4056
4057 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4058 }
4059 }
4060 }
4061
4062 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
4063 for CapabilityStoreDictionaryGetRequest
4064 {
4065 #[inline]
4066 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
4067 Self {
4068 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4069
4070 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4071
4072 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4073 }
4074 }
4075 }
4076
4077 #[derive(PartialEq, Clone, Debug)]
4078 #[repr(C)]
4079 pub struct CapabilityStoreDictionaryGetResponse {}
4080
4081 impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetResponse {
4082 type Encoded = crate::wire::CapabilityStoreDictionaryGetResponse;
4083 }
4084
4085 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetResponse
4086 where
4087 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4088 {
4089 #[inline]
4090 fn encode(
4091 self,
4092 encoder_: &mut ___E,
4093 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4094 _: (),
4095 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4096 *out_ = ::core::mem::MaybeUninit::zeroed();
4097
4098 Ok(())
4099 }
4100 }
4101
4102 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetResponse
4103 where
4104 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4105 {
4106 #[inline]
4107 fn encode_ref(
4108 &self,
4109 encoder_: &mut ___E,
4110 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4111 _: (),
4112 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4113 ::fidl_next::munge! {
4114 let Self::Encoded {
4115
4116 _empty,
4117
4118
4119 } = out_;
4120 }
4121
4122 Ok(())
4123 }
4124 }
4125
4126 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetResponse {
4127 type EncodedOption =
4128 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryGetResponse>;
4129 }
4130
4131 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetResponse
4132 where
4133 ___E: ::fidl_next::Encoder + ?Sized,
4134 CapabilityStoreDictionaryGetResponse: ::fidl_next::Encode<___E>,
4135 {
4136 #[inline]
4137 fn encode_option(
4138 this: ::core::option::Option<Self>,
4139 encoder: &mut ___E,
4140 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4141 _: (),
4142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4143 if let Some(inner) = this {
4144 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4145 ::fidl_next::WireBox::encode_present(out);
4146 } else {
4147 ::fidl_next::WireBox::encode_absent(out);
4148 }
4149
4150 Ok(())
4151 }
4152 }
4153
4154 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetResponse
4155 where
4156 ___E: ::fidl_next::Encoder + ?Sized,
4157 CapabilityStoreDictionaryGetResponse: ::fidl_next::EncodeRef<___E>,
4158 {
4159 #[inline]
4160 fn encode_option_ref(
4161 this: ::core::option::Option<&Self>,
4162 encoder: &mut ___E,
4163 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
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 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetResponse>
4178 for CapabilityStoreDictionaryGetResponse
4179 {
4180 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4181 crate::wire::CapabilityStoreDictionaryGetResponse,
4182 Self,
4183 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4184
4185 #[inline]
4186 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
4187 Self {}
4188 }
4189 }
4190
4191 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetResponse>
4192 for CapabilityStoreDictionaryGetResponse
4193 {
4194 #[inline]
4195 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
4196 Self {}
4197 }
4198 }
4199
4200 #[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"]
4201 #[derive(PartialEq, Clone, Debug)]
4202 #[repr(C)]
4203 pub struct WrappedCapabilityId {
4204 pub id: u64,
4205 }
4206
4207 impl ::fidl_next::Encodable for WrappedCapabilityId {
4208 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4209 Self,
4210 crate::wire::WrappedCapabilityId,
4211 > = unsafe {
4212 ::fidl_next::CopyOptimization::enable_if(
4213 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4214 )
4215 };
4216
4217 type Encoded = crate::wire::WrappedCapabilityId;
4218 }
4219
4220 unsafe impl<___E> ::fidl_next::Encode<___E> for WrappedCapabilityId
4221 where
4222 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4223 {
4224 #[inline]
4225 fn encode(
4226 self,
4227 encoder_: &mut ___E,
4228 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4229 _: (),
4230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4231 ::fidl_next::munge! {
4232 let Self::Encoded {
4233 id,
4234
4235 } = out_;
4236 }
4237
4238 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4239
4240 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4241
4242 Ok(())
4243 }
4244 }
4245
4246 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WrappedCapabilityId
4247 where
4248 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4249 {
4250 #[inline]
4251 fn encode_ref(
4252 &self,
4253 encoder_: &mut ___E,
4254 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4255 _: (),
4256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4257 ::fidl_next::munge! {
4258 let Self::Encoded {
4259
4260 id,
4261
4262 } = out_;
4263 }
4264
4265 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4266
4267 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4268
4269 Ok(())
4270 }
4271 }
4272
4273 impl ::fidl_next::EncodableOption for WrappedCapabilityId {
4274 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>;
4275 }
4276
4277 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WrappedCapabilityId
4278 where
4279 ___E: ::fidl_next::Encoder + ?Sized,
4280 WrappedCapabilityId: ::fidl_next::Encode<___E>,
4281 {
4282 #[inline]
4283 fn encode_option(
4284 this: ::core::option::Option<Self>,
4285 encoder: &mut ___E,
4286 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4287 _: (),
4288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4289 if let Some(inner) = this {
4290 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4291 ::fidl_next::WireBox::encode_present(out);
4292 } else {
4293 ::fidl_next::WireBox::encode_absent(out);
4294 }
4295
4296 Ok(())
4297 }
4298 }
4299
4300 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WrappedCapabilityId
4301 where
4302 ___E: ::fidl_next::Encoder + ?Sized,
4303 WrappedCapabilityId: ::fidl_next::EncodeRef<___E>,
4304 {
4305 #[inline]
4306 fn encode_option_ref(
4307 this: ::core::option::Option<&Self>,
4308 encoder: &mut ___E,
4309 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4310 _: (),
4311 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4312 if let Some(inner) = this {
4313 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4314 ::fidl_next::WireBox::encode_present(out);
4315 } else {
4316 ::fidl_next::WireBox::encode_absent(out);
4317 }
4318
4319 Ok(())
4320 }
4321 }
4322
4323 impl ::fidl_next::FromWire<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
4324 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4325 crate::wire::WrappedCapabilityId,
4326 Self,
4327 > = unsafe {
4328 ::fidl_next::CopyOptimization::enable_if(
4329 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4330 .is_enabled(),
4331 )
4332 };
4333
4334 #[inline]
4335 fn from_wire(wire: crate::wire::WrappedCapabilityId) -> Self {
4336 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
4337 }
4338 }
4339
4340 impl ::fidl_next::FromWireRef<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
4341 #[inline]
4342 fn from_wire_ref(wire: &crate::wire::WrappedCapabilityId) -> Self {
4343 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
4344 }
4345 }
4346
4347 pub type WrappedNewCapabilityId = crate::natural::WrappedCapabilityId;
4348
4349 #[derive(PartialEq, Clone, Debug)]
4350 pub struct CapabilityStoreDictionaryRemoveRequest {
4351 pub id: u64,
4352
4353 pub key: ::std::string::String,
4354
4355 pub dest_id: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
4356 }
4357
4358 impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest {
4359 type Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
4360 }
4361
4362 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveRequest
4363 where
4364 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4365 ___E: ::fidl_next::Encoder,
4366 {
4367 #[inline]
4368 fn encode(
4369 self,
4370 encoder_: &mut ___E,
4371 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4372 _: (),
4373 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4374 ::fidl_next::munge! {
4375 let Self::Encoded {
4376 id,
4377 key,
4378 dest_id,
4379
4380 } = out_;
4381 }
4382
4383 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4384
4385 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4386
4387 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
4388
4389 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
4390 ::fidl_next::Constrained::validate(_field, 255)?;
4391
4392 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4393
4394 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4395
4396 Ok(())
4397 }
4398 }
4399
4400 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveRequest
4401 where
4402 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4403 ___E: ::fidl_next::Encoder,
4404 {
4405 #[inline]
4406 fn encode_ref(
4407 &self,
4408 encoder_: &mut ___E,
4409 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4410 _: (),
4411 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4412 ::fidl_next::munge! {
4413 let Self::Encoded {
4414
4415 id,
4416 key,
4417 dest_id,
4418
4419 } = out_;
4420 }
4421
4422 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4423
4424 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4425
4426 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
4427
4428 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
4429 ::fidl_next::Constrained::validate(_field, 255)?;
4430
4431 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
4432
4433 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4434
4435 Ok(())
4436 }
4437 }
4438
4439 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveRequest {
4440 type EncodedOption = ::fidl_next::WireBox<
4441 'static,
4442 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
4443 >;
4444 }
4445
4446 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveRequest
4447 where
4448 ___E: ::fidl_next::Encoder + ?Sized,
4449 CapabilityStoreDictionaryRemoveRequest: ::fidl_next::Encode<___E>,
4450 {
4451 #[inline]
4452 fn encode_option(
4453 this: ::core::option::Option<Self>,
4454 encoder: &mut ___E,
4455 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4456 _: (),
4457 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4458 if let Some(inner) = this {
4459 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4460 ::fidl_next::WireBox::encode_present(out);
4461 } else {
4462 ::fidl_next::WireBox::encode_absent(out);
4463 }
4464
4465 Ok(())
4466 }
4467 }
4468
4469 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveRequest
4470 where
4471 ___E: ::fidl_next::Encoder + ?Sized,
4472 CapabilityStoreDictionaryRemoveRequest: ::fidl_next::EncodeRef<___E>,
4473 {
4474 #[inline]
4475 fn encode_option_ref(
4476 this: ::core::option::Option<&Self>,
4477 encoder: &mut ___E,
4478 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4479 _: (),
4480 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4481 if let Some(inner) = this {
4482 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4483 ::fidl_next::WireBox::encode_present(out);
4484 } else {
4485 ::fidl_next::WireBox::encode_absent(out);
4486 }
4487
4488 Ok(())
4489 }
4490 }
4491
4492 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
4493 for CapabilityStoreDictionaryRemoveRequest
4494 {
4495 #[inline]
4496 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4497 Self {
4498 id: ::fidl_next::FromWire::from_wire(wire.id),
4499
4500 key: ::fidl_next::FromWire::from_wire(wire.key),
4501
4502 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4503 }
4504 }
4505 }
4506
4507 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
4508 for CapabilityStoreDictionaryRemoveRequest
4509 {
4510 #[inline]
4511 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4512 Self {
4513 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4514
4515 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4516
4517 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4518 }
4519 }
4520 }
4521
4522 #[derive(PartialEq, Clone, Debug)]
4523 #[repr(C)]
4524 pub struct CapabilityStoreDictionaryRemoveResponse {}
4525
4526 impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveResponse {
4527 type Encoded = crate::wire::CapabilityStoreDictionaryRemoveResponse;
4528 }
4529
4530 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveResponse
4531 where
4532 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4533 {
4534 #[inline]
4535 fn encode(
4536 self,
4537 encoder_: &mut ___E,
4538 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4539 _: (),
4540 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4541 *out_ = ::core::mem::MaybeUninit::zeroed();
4542
4543 Ok(())
4544 }
4545 }
4546
4547 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveResponse
4548 where
4549 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4550 {
4551 #[inline]
4552 fn encode_ref(
4553 &self,
4554 encoder_: &mut ___E,
4555 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4556 _: (),
4557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4558 ::fidl_next::munge! {
4559 let Self::Encoded {
4560
4561 _empty,
4562
4563
4564 } = out_;
4565 }
4566
4567 Ok(())
4568 }
4569 }
4570
4571 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveResponse {
4572 type EncodedOption =
4573 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryRemoveResponse>;
4574 }
4575
4576 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveResponse
4577 where
4578 ___E: ::fidl_next::Encoder + ?Sized,
4579 CapabilityStoreDictionaryRemoveResponse: ::fidl_next::Encode<___E>,
4580 {
4581 #[inline]
4582 fn encode_option(
4583 this: ::core::option::Option<Self>,
4584 encoder: &mut ___E,
4585 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4586 _: (),
4587 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4588 if let Some(inner) = this {
4589 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4590 ::fidl_next::WireBox::encode_present(out);
4591 } else {
4592 ::fidl_next::WireBox::encode_absent(out);
4593 }
4594
4595 Ok(())
4596 }
4597 }
4598
4599 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveResponse
4600 where
4601 ___E: ::fidl_next::Encoder + ?Sized,
4602 CapabilityStoreDictionaryRemoveResponse: ::fidl_next::EncodeRef<___E>,
4603 {
4604 #[inline]
4605 fn encode_option_ref(
4606 this: ::core::option::Option<&Self>,
4607 encoder: &mut ___E,
4608 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4609 _: (),
4610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4611 if let Some(inner) = this {
4612 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4613 ::fidl_next::WireBox::encode_present(out);
4614 } else {
4615 ::fidl_next::WireBox::encode_absent(out);
4616 }
4617
4618 Ok(())
4619 }
4620 }
4621
4622 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4623 for CapabilityStoreDictionaryRemoveResponse
4624 {
4625 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4626 crate::wire::CapabilityStoreDictionaryRemoveResponse,
4627 Self,
4628 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4629
4630 #[inline]
4631 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4632 Self {}
4633 }
4634 }
4635
4636 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4637 for CapabilityStoreDictionaryRemoveResponse
4638 {
4639 #[inline]
4640 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4641 Self {}
4642 }
4643 }
4644
4645 #[derive(PartialEq, Clone, Debug)]
4646 #[repr(C)]
4647 pub struct CapabilityStoreDictionaryCopyRequest {
4648 pub id: u64,
4649
4650 pub dest_id: u64,
4651 }
4652
4653 impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest {
4654 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4655 Self,
4656 crate::wire::CapabilityStoreDictionaryCopyRequest,
4657 > = unsafe {
4658 ::fidl_next::CopyOptimization::enable_if(
4659 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
4660 && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4661 )
4662 };
4663
4664 type Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest;
4665 }
4666
4667 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest
4668 where
4669 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4670 {
4671 #[inline]
4672 fn encode(
4673 self,
4674 encoder_: &mut ___E,
4675 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4676 _: (),
4677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4678 ::fidl_next::munge! {
4679 let Self::Encoded {
4680 id,
4681 dest_id,
4682
4683 } = out_;
4684 }
4685
4686 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4687
4688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4689
4690 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4691
4692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4693
4694 Ok(())
4695 }
4696 }
4697
4698 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyRequest
4699 where
4700 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4701 {
4702 #[inline]
4703 fn encode_ref(
4704 &self,
4705 encoder_: &mut ___E,
4706 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4707 _: (),
4708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4709 ::fidl_next::munge! {
4710 let Self::Encoded {
4711
4712 id,
4713 dest_id,
4714
4715 } = out_;
4716 }
4717
4718 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4719
4720 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4721
4722 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
4723
4724 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4725
4726 Ok(())
4727 }
4728 }
4729
4730 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyRequest {
4731 type EncodedOption =
4732 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>;
4733 }
4734
4735 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyRequest
4736 where
4737 ___E: ::fidl_next::Encoder + ?Sized,
4738 CapabilityStoreDictionaryCopyRequest: ::fidl_next::Encode<___E>,
4739 {
4740 #[inline]
4741 fn encode_option(
4742 this: ::core::option::Option<Self>,
4743 encoder: &mut ___E,
4744 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4745 _: (),
4746 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4747 if let Some(inner) = this {
4748 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4749 ::fidl_next::WireBox::encode_present(out);
4750 } else {
4751 ::fidl_next::WireBox::encode_absent(out);
4752 }
4753
4754 Ok(())
4755 }
4756 }
4757
4758 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyRequest
4759 where
4760 ___E: ::fidl_next::Encoder + ?Sized,
4761 CapabilityStoreDictionaryCopyRequest: ::fidl_next::EncodeRef<___E>,
4762 {
4763 #[inline]
4764 fn encode_option_ref(
4765 this: ::core::option::Option<&Self>,
4766 encoder: &mut ___E,
4767 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4768 _: (),
4769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4770 if let Some(inner) = this {
4771 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4772 ::fidl_next::WireBox::encode_present(out);
4773 } else {
4774 ::fidl_next::WireBox::encode_absent(out);
4775 }
4776
4777 Ok(())
4778 }
4779 }
4780
4781 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyRequest>
4782 for CapabilityStoreDictionaryCopyRequest
4783 {
4784 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4785 crate::wire::CapabilityStoreDictionaryCopyRequest,
4786 Self,
4787 > = unsafe {
4788 ::fidl_next::CopyOptimization::enable_if(
4789 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4790 .is_enabled()
4791 && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4792 .is_enabled(),
4793 )
4794 };
4795
4796 #[inline]
4797 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4798 Self {
4799 id: ::fidl_next::FromWire::from_wire(wire.id),
4800
4801 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4802 }
4803 }
4804 }
4805
4806 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyRequest>
4807 for CapabilityStoreDictionaryCopyRequest
4808 {
4809 #[inline]
4810 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4811 Self {
4812 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4813
4814 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4815 }
4816 }
4817 }
4818
4819 #[derive(PartialEq, Clone, Debug)]
4820 #[repr(C)]
4821 pub struct CapabilityStoreDictionaryCopyResponse {}
4822
4823 impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyResponse {
4824 type Encoded = crate::wire::CapabilityStoreDictionaryCopyResponse;
4825 }
4826
4827 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyResponse
4828 where
4829 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4830 {
4831 #[inline]
4832 fn encode(
4833 self,
4834 encoder_: &mut ___E,
4835 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4836 _: (),
4837 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4838 *out_ = ::core::mem::MaybeUninit::zeroed();
4839
4840 Ok(())
4841 }
4842 }
4843
4844 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyResponse
4845 where
4846 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4847 {
4848 #[inline]
4849 fn encode_ref(
4850 &self,
4851 encoder_: &mut ___E,
4852 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4853 _: (),
4854 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4855 ::fidl_next::munge! {
4856 let Self::Encoded {
4857
4858 _empty,
4859
4860
4861 } = out_;
4862 }
4863
4864 Ok(())
4865 }
4866 }
4867
4868 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyResponse {
4869 type EncodedOption =
4870 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>;
4871 }
4872
4873 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyResponse
4874 where
4875 ___E: ::fidl_next::Encoder + ?Sized,
4876 CapabilityStoreDictionaryCopyResponse: ::fidl_next::Encode<___E>,
4877 {
4878 #[inline]
4879 fn encode_option(
4880 this: ::core::option::Option<Self>,
4881 encoder: &mut ___E,
4882 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4883 _: (),
4884 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4885 if let Some(inner) = this {
4886 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4887 ::fidl_next::WireBox::encode_present(out);
4888 } else {
4889 ::fidl_next::WireBox::encode_absent(out);
4890 }
4891
4892 Ok(())
4893 }
4894 }
4895
4896 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyResponse
4897 where
4898 ___E: ::fidl_next::Encoder + ?Sized,
4899 CapabilityStoreDictionaryCopyResponse: ::fidl_next::EncodeRef<___E>,
4900 {
4901 #[inline]
4902 fn encode_option_ref(
4903 this: ::core::option::Option<&Self>,
4904 encoder: &mut ___E,
4905 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4906 _: (),
4907 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4908 if let Some(inner) = this {
4909 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4910 ::fidl_next::WireBox::encode_present(out);
4911 } else {
4912 ::fidl_next::WireBox::encode_absent(out);
4913 }
4914
4915 Ok(())
4916 }
4917 }
4918
4919 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyResponse>
4920 for CapabilityStoreDictionaryCopyResponse
4921 {
4922 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4923 crate::wire::CapabilityStoreDictionaryCopyResponse,
4924 Self,
4925 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4926
4927 #[inline]
4928 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4929 Self {}
4930 }
4931 }
4932
4933 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyResponse>
4934 for CapabilityStoreDictionaryCopyResponse
4935 {
4936 #[inline]
4937 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4938 Self {}
4939 }
4940 }
4941
4942 #[derive(PartialEq, Debug)]
4943 pub struct CapabilityStoreDictionaryKeysRequest {
4944 pub id: u64,
4945
4946 pub iterator: ::fidl_next::ServerEnd<
4947 crate::DictionaryKeysIterator,
4948 ::fidl_next::fuchsia::zx::Channel,
4949 >,
4950 }
4951
4952 impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest {
4953 type Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest;
4954 }
4955
4956 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest
4957 where
4958 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4959 ___E: ::fidl_next::fuchsia::HandleEncoder,
4960 {
4961 #[inline]
4962 fn encode(
4963 self,
4964 encoder_: &mut ___E,
4965 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4966 _: (),
4967 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4968 ::fidl_next::munge! {
4969 let Self::Encoded {
4970 id,
4971 iterator,
4972
4973 } = out_;
4974 }
4975
4976 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4977
4978 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4979
4980 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
4981
4982 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
4983
4984 Ok(())
4985 }
4986 }
4987
4988 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysRequest {
4989 type EncodedOption =
4990 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>;
4991 }
4992
4993 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysRequest
4994 where
4995 ___E: ::fidl_next::Encoder + ?Sized,
4996 CapabilityStoreDictionaryKeysRequest: ::fidl_next::Encode<___E>,
4997 {
4998 #[inline]
4999 fn encode_option(
5000 this: ::core::option::Option<Self>,
5001 encoder: &mut ___E,
5002 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5003 _: (),
5004 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5005 if let Some(inner) = this {
5006 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5007 ::fidl_next::WireBox::encode_present(out);
5008 } else {
5009 ::fidl_next::WireBox::encode_absent(out);
5010 }
5011
5012 Ok(())
5013 }
5014 }
5015
5016 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
5017 for CapabilityStoreDictionaryKeysRequest
5018 {
5019 #[inline]
5020 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
5021 Self {
5022 id: ::fidl_next::FromWire::from_wire(wire.id),
5023
5024 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5025 }
5026 }
5027 }
5028
5029 #[derive(PartialEq, Clone, Debug)]
5030 #[repr(C)]
5031 pub struct CapabilityStoreDictionaryKeysResponse {}
5032
5033 impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysResponse {
5034 type Encoded = crate::wire::CapabilityStoreDictionaryKeysResponse;
5035 }
5036
5037 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysResponse
5038 where
5039 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5040 {
5041 #[inline]
5042 fn encode(
5043 self,
5044 encoder_: &mut ___E,
5045 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5046 _: (),
5047 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5048 *out_ = ::core::mem::MaybeUninit::zeroed();
5049
5050 Ok(())
5051 }
5052 }
5053
5054 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryKeysResponse
5055 where
5056 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5057 {
5058 #[inline]
5059 fn encode_ref(
5060 &self,
5061 encoder_: &mut ___E,
5062 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5063 _: (),
5064 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5065 ::fidl_next::munge! {
5066 let Self::Encoded {
5067
5068 _empty,
5069
5070
5071 } = out_;
5072 }
5073
5074 Ok(())
5075 }
5076 }
5077
5078 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysResponse {
5079 type EncodedOption =
5080 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>;
5081 }
5082
5083 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysResponse
5084 where
5085 ___E: ::fidl_next::Encoder + ?Sized,
5086 CapabilityStoreDictionaryKeysResponse: ::fidl_next::Encode<___E>,
5087 {
5088 #[inline]
5089 fn encode_option(
5090 this: ::core::option::Option<Self>,
5091 encoder: &mut ___E,
5092 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5093 _: (),
5094 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5095 if let Some(inner) = this {
5096 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5097 ::fidl_next::WireBox::encode_present(out);
5098 } else {
5099 ::fidl_next::WireBox::encode_absent(out);
5100 }
5101
5102 Ok(())
5103 }
5104 }
5105
5106 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryKeysResponse
5107 where
5108 ___E: ::fidl_next::Encoder + ?Sized,
5109 CapabilityStoreDictionaryKeysResponse: ::fidl_next::EncodeRef<___E>,
5110 {
5111 #[inline]
5112 fn encode_option_ref(
5113 this: ::core::option::Option<&Self>,
5114 encoder: &mut ___E,
5115 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5116 _: (),
5117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5118 if let Some(inner) = this {
5119 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5120 ::fidl_next::WireBox::encode_present(out);
5121 } else {
5122 ::fidl_next::WireBox::encode_absent(out);
5123 }
5124
5125 Ok(())
5126 }
5127 }
5128
5129 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysResponse>
5130 for CapabilityStoreDictionaryKeysResponse
5131 {
5132 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5133 crate::wire::CapabilityStoreDictionaryKeysResponse,
5134 Self,
5135 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5136
5137 #[inline]
5138 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
5139 Self {}
5140 }
5141 }
5142
5143 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryKeysResponse>
5144 for CapabilityStoreDictionaryKeysResponse
5145 {
5146 #[inline]
5147 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
5148 Self {}
5149 }
5150 }
5151
5152 #[derive(PartialEq, Debug)]
5153 pub struct CapabilityStoreDictionaryEnumerateRequest {
5154 pub id: u64,
5155
5156 pub iterator: ::fidl_next::ServerEnd<
5157 crate::DictionaryEnumerateIterator,
5158 ::fidl_next::fuchsia::zx::Channel,
5159 >,
5160 }
5161
5162 impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest {
5163 type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
5164 }
5165
5166 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateRequest
5167 where
5168 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5169 ___E: ::fidl_next::fuchsia::HandleEncoder,
5170 {
5171 #[inline]
5172 fn encode(
5173 self,
5174 encoder_: &mut ___E,
5175 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5176 _: (),
5177 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5178 ::fidl_next::munge! {
5179 let Self::Encoded {
5180 id,
5181 iterator,
5182
5183 } = out_;
5184 }
5185
5186 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5187
5188 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5189
5190 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5191
5192 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
5193
5194 Ok(())
5195 }
5196 }
5197
5198 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateRequest {
5199 type EncodedOption =
5200 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>;
5201 }
5202
5203 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateRequest
5204 where
5205 ___E: ::fidl_next::Encoder + ?Sized,
5206 CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Encode<___E>,
5207 {
5208 #[inline]
5209 fn encode_option(
5210 this: ::core::option::Option<Self>,
5211 encoder: &mut ___E,
5212 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5213 _: (),
5214 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5215 if let Some(inner) = this {
5216 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5217 ::fidl_next::WireBox::encode_present(out);
5218 } else {
5219 ::fidl_next::WireBox::encode_absent(out);
5220 }
5221
5222 Ok(())
5223 }
5224 }
5225
5226 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
5227 for CapabilityStoreDictionaryEnumerateRequest
5228 {
5229 #[inline]
5230 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
5231 Self {
5232 id: ::fidl_next::FromWire::from_wire(wire.id),
5233
5234 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5235 }
5236 }
5237 }
5238
5239 #[derive(PartialEq, Clone, Debug)]
5240 #[repr(C)]
5241 pub struct CapabilityStoreDictionaryEnumerateResponse {}
5242
5243 impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateResponse {
5244 type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateResponse;
5245 }
5246
5247 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateResponse
5248 where
5249 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5250 {
5251 #[inline]
5252 fn encode(
5253 self,
5254 encoder_: &mut ___E,
5255 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5256 _: (),
5257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5258 *out_ = ::core::mem::MaybeUninit::zeroed();
5259
5260 Ok(())
5261 }
5262 }
5263
5264 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryEnumerateResponse
5265 where
5266 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5267 {
5268 #[inline]
5269 fn encode_ref(
5270 &self,
5271 encoder_: &mut ___E,
5272 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5273 _: (),
5274 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5275 ::fidl_next::munge! {
5276 let Self::Encoded {
5277
5278 _empty,
5279
5280
5281 } = out_;
5282 }
5283
5284 Ok(())
5285 }
5286 }
5287
5288 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateResponse {
5289 type EncodedOption =
5290 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateResponse>;
5291 }
5292
5293 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateResponse
5294 where
5295 ___E: ::fidl_next::Encoder + ?Sized,
5296 CapabilityStoreDictionaryEnumerateResponse: ::fidl_next::Encode<___E>,
5297 {
5298 #[inline]
5299 fn encode_option(
5300 this: ::core::option::Option<Self>,
5301 encoder: &mut ___E,
5302 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5303 _: (),
5304 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5305 if let Some(inner) = this {
5306 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5307 ::fidl_next::WireBox::encode_present(out);
5308 } else {
5309 ::fidl_next::WireBox::encode_absent(out);
5310 }
5311
5312 Ok(())
5313 }
5314 }
5315
5316 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryEnumerateResponse
5317 where
5318 ___E: ::fidl_next::Encoder + ?Sized,
5319 CapabilityStoreDictionaryEnumerateResponse: ::fidl_next::EncodeRef<___E>,
5320 {
5321 #[inline]
5322 fn encode_option_ref(
5323 this: ::core::option::Option<&Self>,
5324 encoder: &mut ___E,
5325 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5326 _: (),
5327 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5328 if let Some(inner) = this {
5329 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5330 ::fidl_next::WireBox::encode_present(out);
5331 } else {
5332 ::fidl_next::WireBox::encode_absent(out);
5333 }
5334
5335 Ok(())
5336 }
5337 }
5338
5339 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
5340 for CapabilityStoreDictionaryEnumerateResponse
5341 {
5342 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5343 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
5344 Self,
5345 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5346
5347 #[inline]
5348 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
5349 Self {}
5350 }
5351 }
5352
5353 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
5354 for CapabilityStoreDictionaryEnumerateResponse
5355 {
5356 #[inline]
5357 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
5358 Self {}
5359 }
5360 }
5361
5362 #[derive(PartialEq, Debug)]
5363 pub struct CapabilityStoreDictionaryDrainRequest {
5364 pub id: u64,
5365
5366 pub iterator: ::core::option::Option<
5367 ::fidl_next::ServerEnd<
5368 crate::DictionaryDrainIterator,
5369 ::fidl_next::fuchsia::zx::Channel,
5370 >,
5371 >,
5372 }
5373
5374 impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest {
5375 type Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest;
5376 }
5377
5378 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainRequest
5379 where
5380 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5381 ___E: ::fidl_next::fuchsia::HandleEncoder,
5382 {
5383 #[inline]
5384 fn encode(
5385 self,
5386 encoder_: &mut ___E,
5387 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5388 _: (),
5389 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5390 ::fidl_next::munge! {
5391 let Self::Encoded {
5392 id,
5393 iterator,
5394
5395 } = out_;
5396 }
5397
5398 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5399
5400 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5401
5402 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5403
5404 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
5405
5406 Ok(())
5407 }
5408 }
5409
5410 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainRequest {
5411 type EncodedOption =
5412 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>;
5413 }
5414
5415 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainRequest
5416 where
5417 ___E: ::fidl_next::Encoder + ?Sized,
5418 CapabilityStoreDictionaryDrainRequest: ::fidl_next::Encode<___E>,
5419 {
5420 #[inline]
5421 fn encode_option(
5422 this: ::core::option::Option<Self>,
5423 encoder: &mut ___E,
5424 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5425 _: (),
5426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5427 if let Some(inner) = this {
5428 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5429 ::fidl_next::WireBox::encode_present(out);
5430 } else {
5431 ::fidl_next::WireBox::encode_absent(out);
5432 }
5433
5434 Ok(())
5435 }
5436 }
5437
5438 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
5439 for CapabilityStoreDictionaryDrainRequest
5440 {
5441 #[inline]
5442 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
5443 Self {
5444 id: ::fidl_next::FromWire::from_wire(wire.id),
5445
5446 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5447 }
5448 }
5449 }
5450
5451 #[derive(PartialEq, Clone, Debug)]
5452 #[repr(C)]
5453 pub struct CapabilityStoreDictionaryDrainResponse {}
5454
5455 impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainResponse {
5456 type Encoded = crate::wire::CapabilityStoreDictionaryDrainResponse;
5457 }
5458
5459 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainResponse
5460 where
5461 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5462 {
5463 #[inline]
5464 fn encode(
5465 self,
5466 encoder_: &mut ___E,
5467 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5468 _: (),
5469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5470 *out_ = ::core::mem::MaybeUninit::zeroed();
5471
5472 Ok(())
5473 }
5474 }
5475
5476 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryDrainResponse
5477 where
5478 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5479 {
5480 #[inline]
5481 fn encode_ref(
5482 &self,
5483 encoder_: &mut ___E,
5484 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5485 _: (),
5486 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5487 ::fidl_next::munge! {
5488 let Self::Encoded {
5489
5490 _empty,
5491
5492
5493 } = out_;
5494 }
5495
5496 Ok(())
5497 }
5498 }
5499
5500 impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainResponse {
5501 type EncodedOption =
5502 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainResponse>;
5503 }
5504
5505 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainResponse
5506 where
5507 ___E: ::fidl_next::Encoder + ?Sized,
5508 CapabilityStoreDictionaryDrainResponse: ::fidl_next::Encode<___E>,
5509 {
5510 #[inline]
5511 fn encode_option(
5512 this: ::core::option::Option<Self>,
5513 encoder: &mut ___E,
5514 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5515 _: (),
5516 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5517 if let Some(inner) = this {
5518 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5519 ::fidl_next::WireBox::encode_present(out);
5520 } else {
5521 ::fidl_next::WireBox::encode_absent(out);
5522 }
5523
5524 Ok(())
5525 }
5526 }
5527
5528 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryDrainResponse
5529 where
5530 ___E: ::fidl_next::Encoder + ?Sized,
5531 CapabilityStoreDictionaryDrainResponse: ::fidl_next::EncodeRef<___E>,
5532 {
5533 #[inline]
5534 fn encode_option_ref(
5535 this: ::core::option::Option<&Self>,
5536 encoder: &mut ___E,
5537 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5538 _: (),
5539 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5540 if let Some(inner) = this {
5541 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5542 ::fidl_next::WireBox::encode_present(out);
5543 } else {
5544 ::fidl_next::WireBox::encode_absent(out);
5545 }
5546
5547 Ok(())
5548 }
5549 }
5550
5551 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainResponse>
5552 for CapabilityStoreDictionaryDrainResponse
5553 {
5554 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5555 crate::wire::CapabilityStoreDictionaryDrainResponse,
5556 Self,
5557 > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5558
5559 #[inline]
5560 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
5561 Self {}
5562 }
5563 }
5564
5565 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryDrainResponse>
5566 for CapabilityStoreDictionaryDrainResponse
5567 {
5568 #[inline]
5569 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
5570 Self {}
5571 }
5572 }
5573
5574 #[derive(PartialEq, Debug)]
5575 pub struct CapabilityStoreExportResponse {
5576 pub capability: crate::natural::Capability,
5577 }
5578
5579 impl ::fidl_next::Encodable for CapabilityStoreExportResponse {
5580 type Encoded = crate::wire::CapabilityStoreExportResponse<'static>;
5581 }
5582
5583 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse
5584 where
5585 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5586 ___E: ::fidl_next::Encoder,
5587 ___E: ::fidl_next::fuchsia::HandleEncoder,
5588 {
5589 #[inline]
5590 fn encode(
5591 self,
5592 encoder_: &mut ___E,
5593 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5594 _: (),
5595 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5596 ::fidl_next::munge! {
5597 let Self::Encoded {
5598 capability,
5599
5600 } = out_;
5601 }
5602
5603 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
5604
5605 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
5606
5607 Ok(())
5608 }
5609 }
5610
5611 impl ::fidl_next::EncodableOption for CapabilityStoreExportResponse {
5612 type EncodedOption =
5613 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>;
5614 }
5615
5616 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportResponse
5617 where
5618 ___E: ::fidl_next::Encoder + ?Sized,
5619 CapabilityStoreExportResponse: ::fidl_next::Encode<___E>,
5620 {
5621 #[inline]
5622 fn encode_option(
5623 this: ::core::option::Option<Self>,
5624 encoder: &mut ___E,
5625 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5626 _: (),
5627 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5628 if let Some(inner) = this {
5629 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5630 ::fidl_next::WireBox::encode_present(out);
5631 } else {
5632 ::fidl_next::WireBox::encode_absent(out);
5633 }
5634
5635 Ok(())
5636 }
5637 }
5638
5639 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
5640 for CapabilityStoreExportResponse
5641 {
5642 #[inline]
5643 fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
5644 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
5645 }
5646 }
5647
5648 #[derive(PartialEq, Debug)]
5649 pub struct CapabilityStoreImportRequest {
5650 pub id: u64,
5651
5652 pub capability: crate::natural::Capability,
5653 }
5654
5655 impl ::fidl_next::Encodable for CapabilityStoreImportRequest {
5656 type Encoded = crate::wire::CapabilityStoreImportRequest<'static>;
5657 }
5658
5659 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest
5660 where
5661 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5662 ___E: ::fidl_next::Encoder,
5663 ___E: ::fidl_next::fuchsia::HandleEncoder,
5664 {
5665 #[inline]
5666 fn encode(
5667 self,
5668 encoder_: &mut ___E,
5669 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5670 _: (),
5671 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5672 ::fidl_next::munge! {
5673 let Self::Encoded {
5674 id,
5675 capability,
5676
5677 } = out_;
5678 }
5679
5680 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5681
5682 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5683
5684 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
5685
5686 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
5687
5688 Ok(())
5689 }
5690 }
5691
5692 impl ::fidl_next::EncodableOption for CapabilityStoreImportRequest {
5693 type EncodedOption =
5694 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>;
5695 }
5696
5697 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportRequest
5698 where
5699 ___E: ::fidl_next::Encoder + ?Sized,
5700 CapabilityStoreImportRequest: ::fidl_next::Encode<___E>,
5701 {
5702 #[inline]
5703 fn encode_option(
5704 this: ::core::option::Option<Self>,
5705 encoder: &mut ___E,
5706 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5707 _: (),
5708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5709 if let Some(inner) = this {
5710 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5711 ::fidl_next::WireBox::encode_present(out);
5712 } else {
5713 ::fidl_next::WireBox::encode_absent(out);
5714 }
5715
5716 Ok(())
5717 }
5718 }
5719
5720 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
5721 for CapabilityStoreImportRequest
5722 {
5723 #[inline]
5724 fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
5725 Self {
5726 id: ::fidl_next::FromWire::from_wire(wire.id),
5727
5728 capability: ::fidl_next::FromWire::from_wire(wire.capability),
5729 }
5730 }
5731 }
5732
5733 #[derive(PartialEq, Debug)]
5734 pub struct CapabilityStoreDirConnectorCreateRequest {
5735 pub id: u64,
5736
5737 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
5738 }
5739
5740 impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest {
5741 type Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest;
5742 }
5743
5744 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateRequest
5745 where
5746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5747 ___E: ::fidl_next::fuchsia::HandleEncoder,
5748 {
5749 #[inline]
5750 fn encode(
5751 self,
5752 encoder_: &mut ___E,
5753 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5754 _: (),
5755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5756 ::fidl_next::munge! {
5757 let Self::Encoded {
5758 id,
5759 receiver,
5760
5761 } = out_;
5762 }
5763
5764 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5765
5766 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5767
5768 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
5769
5770 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
5771
5772 Ok(())
5773 }
5774 }
5775
5776 impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateRequest {
5777 type EncodedOption =
5778 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>;
5779 }
5780
5781 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateRequest
5782 where
5783 ___E: ::fidl_next::Encoder + ?Sized,
5784 CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Encode<___E>,
5785 {
5786 #[inline]
5787 fn encode_option(
5788 this: ::core::option::Option<Self>,
5789 encoder: &mut ___E,
5790 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5791 _: (),
5792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5793 if let Some(inner) = this {
5794 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5795 ::fidl_next::WireBox::encode_present(out);
5796 } else {
5797 ::fidl_next::WireBox::encode_absent(out);
5798 }
5799
5800 Ok(())
5801 }
5802 }
5803
5804 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
5805 for CapabilityStoreDirConnectorCreateRequest
5806 {
5807 #[inline]
5808 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
5809 Self {
5810 id: ::fidl_next::FromWire::from_wire(wire.id),
5811
5812 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
5813 }
5814 }
5815 }
5816
5817 #[derive(PartialEq, Debug)]
5818 pub struct CapabilityStoreDirConnectorOpenRequest {
5819 pub id: u64,
5820
5821 pub server_end: ::fidl_next::ServerEnd<
5822 ::fidl_next_fuchsia_io::Directory,
5823 ::fidl_next::fuchsia::zx::Channel,
5824 >,
5825 }
5826
5827 impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest {
5828 type Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest;
5829 }
5830
5831 unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenRequest
5832 where
5833 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5834 ___E: ::fidl_next::fuchsia::HandleEncoder,
5835 {
5836 #[inline]
5837 fn encode(
5838 self,
5839 encoder_: &mut ___E,
5840 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5841 _: (),
5842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5843 ::fidl_next::munge! {
5844 let Self::Encoded {
5845 id,
5846 server_end,
5847
5848 } = out_;
5849 }
5850
5851 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5852
5853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5854
5855 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
5856
5857 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
5858
5859 Ok(())
5860 }
5861 }
5862
5863 impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenRequest {
5864 type EncodedOption =
5865 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenRequest>;
5866 }
5867
5868 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenRequest
5869 where
5870 ___E: ::fidl_next::Encoder + ?Sized,
5871 CapabilityStoreDirConnectorOpenRequest: ::fidl_next::Encode<___E>,
5872 {
5873 #[inline]
5874 fn encode_option(
5875 this: ::core::option::Option<Self>,
5876 encoder: &mut ___E,
5877 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5878 _: (),
5879 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5880 if let Some(inner) = this {
5881 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5882 ::fidl_next::WireBox::encode_present(out);
5883 } else {
5884 ::fidl_next::WireBox::encode_absent(out);
5885 }
5886
5887 Ok(())
5888 }
5889 }
5890
5891 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest>
5892 for CapabilityStoreDirConnectorOpenRequest
5893 {
5894 #[inline]
5895 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenRequest) -> Self {
5896 Self {
5897 id: ::fidl_next::FromWire::from_wire(wire.id),
5898
5899 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
5900 }
5901 }
5902 }
5903
5904 #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
5905 #[derive(PartialEq, Debug)]
5906 #[repr(C)]
5907 pub struct InstanceToken {
5908 pub token: ::fidl_next::fuchsia::zx::EventPair,
5909 }
5910
5911 impl ::fidl_next::Encodable for InstanceToken {
5912 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
5913 ::fidl_next::CopyOptimization::enable_if(
5914 true
5915
5916 && <
5917 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
5918 >::COPY_OPTIMIZATION.is_enabled()
5919
5920 )
5921 };
5922
5923 type Encoded = crate::wire::InstanceToken;
5924 }
5925
5926 unsafe impl<___E> ::fidl_next::Encode<___E> for InstanceToken
5927 where
5928 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5929 ___E: ::fidl_next::fuchsia::HandleEncoder,
5930 {
5931 #[inline]
5932 fn encode(
5933 self,
5934 encoder_: &mut ___E,
5935 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5936 _: (),
5937 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5938 ::fidl_next::munge! {
5939 let Self::Encoded {
5940 token,
5941
5942 } = out_;
5943 }
5944
5945 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5946
5947 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
5948
5949 Ok(())
5950 }
5951 }
5952
5953 impl ::fidl_next::EncodableOption for InstanceToken {
5954 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::InstanceToken>;
5955 }
5956
5957 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for InstanceToken
5958 where
5959 ___E: ::fidl_next::Encoder + ?Sized,
5960 InstanceToken: ::fidl_next::Encode<___E>,
5961 {
5962 #[inline]
5963 fn encode_option(
5964 this: ::core::option::Option<Self>,
5965 encoder: &mut ___E,
5966 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5967 _: (),
5968 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5969 if let Some(inner) = this {
5970 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5971 ::fidl_next::WireBox::encode_present(out);
5972 } else {
5973 ::fidl_next::WireBox::encode_absent(out);
5974 }
5975
5976 Ok(())
5977 }
5978 }
5979
5980 impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
5981 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
5982 ::fidl_next::CopyOptimization::enable_if(
5983 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
5984 ::fidl_next::fuchsia::WireEventPair,
5985 >>::COPY_OPTIMIZATION
5986 .is_enabled(),
5987 )
5988 };
5989
5990 #[inline]
5991 fn from_wire(wire: crate::wire::InstanceToken) -> Self {
5992 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
5993 }
5994 }
5995
5996 #[doc = " A request for a route.\n"]
5997 #[derive(PartialEq, Debug, Default)]
5998 pub struct RouteRequest {
5999 pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
6000
6001 pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
6002 }
6003
6004 impl RouteRequest {
6005 fn __max_ordinal(&self) -> usize {
6006 if self.metadata.is_some() {
6007 return 2;
6008 }
6009
6010 if self.requesting.is_some() {
6011 return 1;
6012 }
6013
6014 0
6015 }
6016 }
6017
6018 impl ::fidl_next::Encodable for RouteRequest {
6019 type Encoded = crate::wire::RouteRequest<'static>;
6020 }
6021
6022 unsafe impl<___E> ::fidl_next::Encode<___E> for RouteRequest
6023 where
6024 ___E: ::fidl_next::Encoder + ?Sized,
6025 ___E: ::fidl_next::fuchsia::HandleEncoder,
6026 {
6027 #[inline]
6028 fn encode(
6029 mut self,
6030 encoder: &mut ___E,
6031 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6032 _: (),
6033 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6034 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
6035
6036 let max_ord = self.__max_ordinal();
6037
6038 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
6039 ::fidl_next::Wire::zero_padding(&mut out);
6040
6041 let mut preallocated =
6042 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
6043
6044 for i in 1..=max_ord {
6045 match i {
6046 2 => {
6047 if let Some(value) = self.metadata.take() {
6048 ::fidl_next::WireEnvelope::encode_value(
6049 value,
6050 preallocated.encoder,
6051 &mut out,
6052 (),
6053 )?;
6054 } else {
6055 ::fidl_next::WireEnvelope::encode_zero(&mut out)
6056 }
6057 }
6058
6059 1 => {
6060 if let Some(value) = self.requesting.take() {
6061 ::fidl_next::WireEnvelope::encode_value(
6062 value,
6063 preallocated.encoder,
6064 &mut out,
6065 (),
6066 )?;
6067 } else {
6068 ::fidl_next::WireEnvelope::encode_zero(&mut out)
6069 }
6070 }
6071
6072 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
6073 }
6074 unsafe {
6075 preallocated.write_next(out.assume_init_ref());
6076 }
6077 }
6078
6079 ::fidl_next::WireTable::encode_len(table, max_ord);
6080
6081 Ok(())
6082 }
6083 }
6084
6085 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
6086 #[inline]
6087 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
6088 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6089
6090 let requesting = wire_.table.get(1);
6091
6092 let metadata = wire_.table.get(2);
6093
6094 Self {
6095 requesting: requesting.map(|envelope| {
6096 ::fidl_next::FromWire::from_wire(unsafe {
6097 envelope.read_unchecked::<crate::wire::InstanceToken>()
6098 })
6099 }),
6100
6101 metadata: metadata.map(|envelope| {
6102 ::fidl_next::FromWire::from_wire(unsafe {
6103 envelope.read_unchecked::<crate::wire::DictionaryRef>()
6104 })
6105 }),
6106 }
6107 }
6108 }
6109
6110 #[derive(PartialEq, Debug)]
6111 pub enum ConnectorRouterRouteResponse {
6112 Connector(crate::natural::Connector),
6113
6114 Unavailable(crate::natural::Unit),
6115 }
6116
6117 impl ::fidl_next::Encodable for ConnectorRouterRouteResponse {
6118 type Encoded = crate::wire::ConnectorRouterRouteResponse;
6119 }
6120
6121 unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectorRouterRouteResponse
6122 where
6123 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6124 ___E: ::fidl_next::fuchsia::HandleEncoder,
6125 {
6126 #[inline]
6127 fn encode(
6128 self,
6129 encoder: &mut ___E,
6130 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6131 _: (),
6132 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6133 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
6134
6135 match self {
6136 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
6137 ___E,
6138 crate::natural::Connector,
6139 >(value, 1, encoder, raw, ())?,
6140
6141 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
6142 ___E,
6143 crate::natural::Unit,
6144 >(value, 2, encoder, raw, ())?,
6145 }
6146
6147 Ok(())
6148 }
6149 }
6150
6151 impl ::fidl_next::EncodableOption for ConnectorRouterRouteResponse {
6152 type EncodedOption = crate::wire_optional::ConnectorRouterRouteResponse;
6153 }
6154
6155 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConnectorRouterRouteResponse
6156 where
6157 ___E: ?Sized,
6158 ConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
6159 {
6160 #[inline]
6161 fn encode_option(
6162 this: ::core::option::Option<Self>,
6163 encoder: &mut ___E,
6164 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6165 _: (),
6166 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6167 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
6168
6169 if let Some(inner) = this {
6170 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6171 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6172 } else {
6173 ::fidl_next::RawWireUnion::encode_absent(raw);
6174 }
6175
6176 Ok(())
6177 }
6178 }
6179
6180 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
6181 for ConnectorRouterRouteResponse
6182 {
6183 #[inline]
6184 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
6185 let wire = ::core::mem::ManuallyDrop::new(wire);
6186 match wire.raw.ordinal() {
6187 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
6188 wire.raw.get().read_unchecked::<crate::wire::Connector>()
6189 })),
6190
6191 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
6192 wire.raw.get().read_unchecked::<crate::wire::Unit>()
6193 })),
6194
6195 _ => unsafe { ::core::hint::unreachable_unchecked() },
6196 }
6197 }
6198 }
6199
6200 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
6201 for ConnectorRouterRouteResponse
6202 {
6203 #[inline]
6204 fn from_wire_option(
6205 wire: crate::wire_optional::ConnectorRouterRouteResponse,
6206 ) -> ::core::option::Option<Self> {
6207 if let Some(inner) = wire.into_option() {
6208 Some(::fidl_next::FromWire::from_wire(inner))
6209 } else {
6210 None
6211 }
6212 }
6213 }
6214
6215 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
6216 for Box<ConnectorRouterRouteResponse>
6217 {
6218 #[inline]
6219 fn from_wire_option(
6220 wire: crate::wire_optional::ConnectorRouterRouteResponse,
6221 ) -> ::core::option::Option<Self> {
6222 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
6223 crate::wire_optional::ConnectorRouterRouteResponse,
6224 >>::from_wire_option(wire)
6225 .map(Box::new)
6226 }
6227 }
6228
6229 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6230 #[repr(u32)]
6231 pub enum RouterError {
6232 NotFound = 1,
6233 InvalidArgs = 2,
6234 NotSupported = 3,
6235 Internal = 4,
6236 UnknownOrdinal_(u32) = 5,
6237 }
6238
6239 impl ::fidl_next::Encodable for RouterError {
6240 type Encoded = crate::wire::RouterError;
6241 }
6242 impl ::std::convert::From<u32> for RouterError {
6243 fn from(value: u32) -> Self {
6244 match value {
6245 1 => Self::NotFound,
6246 2 => Self::InvalidArgs,
6247 3 => Self::NotSupported,
6248 4 => Self::Internal,
6249
6250 _ => Self::UnknownOrdinal_(value),
6251 }
6252 }
6253 }
6254
6255 unsafe impl<___E> ::fidl_next::Encode<___E> for RouterError
6256 where
6257 ___E: ?Sized,
6258 {
6259 #[inline]
6260 fn encode(
6261 self,
6262 encoder: &mut ___E,
6263 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6264 _: (),
6265 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6266 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
6267 }
6268 }
6269
6270 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RouterError
6271 where
6272 ___E: ?Sized,
6273 {
6274 #[inline]
6275 fn encode_ref(
6276 &self,
6277 encoder: &mut ___E,
6278 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6279 _: (),
6280 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6281 ::fidl_next::munge!(let crate::wire::RouterError { value } = out);
6282 let _ = value.write(::fidl_next::WireU32::from(match *self {
6283 Self::NotFound => 1,
6284
6285 Self::InvalidArgs => 2,
6286
6287 Self::NotSupported => 3,
6288
6289 Self::Internal => 4,
6290
6291 Self::UnknownOrdinal_(value) => value,
6292 }));
6293
6294 Ok(())
6295 }
6296 }
6297
6298 impl ::core::convert::From<crate::wire::RouterError> for RouterError {
6299 fn from(wire: crate::wire::RouterError) -> Self {
6300 match u32::from(wire.value) {
6301 1 => Self::NotFound,
6302
6303 2 => Self::InvalidArgs,
6304
6305 3 => Self::NotSupported,
6306
6307 4 => Self::Internal,
6308
6309 value => Self::UnknownOrdinal_(value),
6310 }
6311 }
6312 }
6313
6314 impl ::fidl_next::FromWire<crate::wire::RouterError> for RouterError {
6315 #[inline]
6316 fn from_wire(wire: crate::wire::RouterError) -> Self {
6317 Self::from(wire)
6318 }
6319 }
6320
6321 impl ::fidl_next::FromWireRef<crate::wire::RouterError> for RouterError {
6322 #[inline]
6323 fn from_wire_ref(wire: &crate::wire::RouterError) -> Self {
6324 Self::from(*wire)
6325 }
6326 }
6327
6328 #[derive(PartialEq, Debug)]
6329 pub enum DataRouterRouteResponse {
6330 Data(crate::natural::Data),
6331
6332 Unavailable(crate::natural::Unit),
6333 }
6334
6335 impl ::fidl_next::Encodable for DataRouterRouteResponse {
6336 type Encoded = crate::wire::DataRouterRouteResponse<'static>;
6337 }
6338
6339 unsafe impl<___E> ::fidl_next::Encode<___E> for DataRouterRouteResponse
6340 where
6341 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6342 ___E: ::fidl_next::Encoder,
6343 ___E: ::fidl_next::fuchsia::HandleEncoder,
6344 {
6345 #[inline]
6346 fn encode(
6347 self,
6348 encoder: &mut ___E,
6349 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6350 _: (),
6351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6352 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
6353
6354 match self {
6355 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
6356 ___E,
6357 crate::natural::Data,
6358 >(value, 1, encoder, raw, ())?,
6359
6360 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as::<
6361 ___E,
6362 crate::natural::Unit,
6363 >(value, 2, encoder, raw, ())?,
6364 }
6365
6366 Ok(())
6367 }
6368 }
6369
6370 impl ::fidl_next::EncodableOption for DataRouterRouteResponse {
6371 type EncodedOption = crate::wire_optional::DataRouterRouteResponse<'static>;
6372 }
6373
6374 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DataRouterRouteResponse
6375 where
6376 ___E: ?Sized,
6377 DataRouterRouteResponse: ::fidl_next::Encode<___E>,
6378 {
6379 #[inline]
6380 fn encode_option(
6381 this: ::core::option::Option<Self>,
6382 encoder: &mut ___E,
6383 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6384 _: (),
6385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6386 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
6387
6388 if let Some(inner) = this {
6389 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6390 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6391 } else {
6392 ::fidl_next::RawWireUnion::encode_absent(raw);
6393 }
6394
6395 Ok(())
6396 }
6397 }
6398
6399 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
6400 for DataRouterRouteResponse
6401 {
6402 #[inline]
6403 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
6404 let wire = ::core::mem::ManuallyDrop::new(wire);
6405 match wire.raw.ordinal() {
6406 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
6407 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
6408 })),
6409
6410 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
6411 wire.raw.get().read_unchecked::<crate::wire::Unit>()
6412 })),
6413
6414 _ => unsafe { ::core::hint::unreachable_unchecked() },
6415 }
6416 }
6417 }
6418
6419 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
6420 for DataRouterRouteResponse
6421 {
6422 #[inline]
6423 fn from_wire_option(
6424 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
6425 ) -> ::core::option::Option<Self> {
6426 if let Some(inner) = wire.into_option() {
6427 Some(::fidl_next::FromWire::from_wire(inner))
6428 } else {
6429 None
6430 }
6431 }
6432 }
6433
6434 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
6435 for Box<DataRouterRouteResponse>
6436 {
6437 #[inline]
6438 fn from_wire_option(
6439 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
6440 ) -> ::core::option::Option<Self> {
6441 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
6442 crate::wire_optional::DataRouterRouteResponse<'de>,
6443 >>::from_wire_option(wire)
6444 .map(Box::new)
6445 }
6446 }
6447
6448 #[derive(PartialEq, Clone, Debug)]
6449 pub struct DictionaryDrainIteratorGetNextRequest {
6450 pub start_id: u64,
6451
6452 pub limit: u32,
6453 }
6454
6455 impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest {
6456 type Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest;
6457 }
6458
6459 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextRequest
6460 where
6461 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6462 {
6463 #[inline]
6464 fn encode(
6465 self,
6466 encoder_: &mut ___E,
6467 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6468 _: (),
6469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6470 ::fidl_next::munge! {
6471 let Self::Encoded {
6472 start_id,
6473 limit,
6474
6475 } = out_;
6476 }
6477
6478 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
6479
6480 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6481
6482 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
6483
6484 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6485
6486 Ok(())
6487 }
6488 }
6489
6490 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryDrainIteratorGetNextRequest
6491 where
6492 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6493 {
6494 #[inline]
6495 fn encode_ref(
6496 &self,
6497 encoder_: &mut ___E,
6498 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6499 _: (),
6500 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6501 ::fidl_next::munge! {
6502 let Self::Encoded {
6503
6504 start_id,
6505 limit,
6506
6507 } = out_;
6508 }
6509
6510 ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id, ())?;
6511
6512 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6513
6514 ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit, ())?;
6515
6516 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6517
6518 Ok(())
6519 }
6520 }
6521
6522 impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextRequest {
6523 type EncodedOption =
6524 ::fidl_next::WireBox<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>;
6525 }
6526
6527 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextRequest
6528 where
6529 ___E: ::fidl_next::Encoder + ?Sized,
6530 DictionaryDrainIteratorGetNextRequest: ::fidl_next::Encode<___E>,
6531 {
6532 #[inline]
6533 fn encode_option(
6534 this: ::core::option::Option<Self>,
6535 encoder: &mut ___E,
6536 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6537 _: (),
6538 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6539 if let Some(inner) = this {
6540 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6541 ::fidl_next::WireBox::encode_present(out);
6542 } else {
6543 ::fidl_next::WireBox::encode_absent(out);
6544 }
6545
6546 Ok(())
6547 }
6548 }
6549
6550 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryDrainIteratorGetNextRequest
6551 where
6552 ___E: ::fidl_next::Encoder + ?Sized,
6553 DictionaryDrainIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
6554 {
6555 #[inline]
6556 fn encode_option_ref(
6557 this: ::core::option::Option<&Self>,
6558 encoder: &mut ___E,
6559 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6560 _: (),
6561 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6562 if let Some(inner) = this {
6563 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6564 ::fidl_next::WireBox::encode_present(out);
6565 } else {
6566 ::fidl_next::WireBox::encode_absent(out);
6567 }
6568
6569 Ok(())
6570 }
6571 }
6572
6573 impl ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextRequest>
6574 for DictionaryDrainIteratorGetNextRequest
6575 {
6576 #[inline]
6577 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
6578 Self {
6579 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
6580
6581 limit: ::fidl_next::FromWire::from_wire(wire.limit),
6582 }
6583 }
6584 }
6585
6586 impl ::fidl_next::FromWireRef<crate::wire::DictionaryDrainIteratorGetNextRequest>
6587 for DictionaryDrainIteratorGetNextRequest
6588 {
6589 #[inline]
6590 fn from_wire_ref(wire: &crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
6591 Self {
6592 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
6593
6594 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
6595 }
6596 }
6597 }
6598
6599 #[derive(PartialEq, Debug)]
6600 pub struct DictionaryDrainIteratorGetNextResponse {
6601 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
6602
6603 pub end_id: u64,
6604 }
6605
6606 impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse {
6607 type Encoded = crate::wire::DictionaryDrainIteratorGetNextResponse<'static>;
6608 }
6609
6610 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextResponse
6611 where
6612 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6613 ___E: ::fidl_next::Encoder,
6614 ___E: ::fidl_next::fuchsia::HandleEncoder,
6615 {
6616 #[inline]
6617 fn encode(
6618 self,
6619 encoder_: &mut ___E,
6620 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6621 _: (),
6622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6623 ::fidl_next::munge! {
6624 let Self::Encoded {
6625 items,
6626 end_id,
6627
6628 } = out_;
6629 }
6630
6631 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
6632
6633 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
6634 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6635
6636 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
6637
6638 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
6639
6640 Ok(())
6641 }
6642 }
6643
6644 impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextResponse {
6645 type EncodedOption = ::fidl_next::WireBox<
6646 'static,
6647 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
6648 >;
6649 }
6650
6651 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextResponse
6652 where
6653 ___E: ::fidl_next::Encoder + ?Sized,
6654 DictionaryDrainIteratorGetNextResponse: ::fidl_next::Encode<___E>,
6655 {
6656 #[inline]
6657 fn encode_option(
6658 this: ::core::option::Option<Self>,
6659 encoder: &mut ___E,
6660 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6661 _: (),
6662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6663 if let Some(inner) = this {
6664 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6665 ::fidl_next::WireBox::encode_present(out);
6666 } else {
6667 ::fidl_next::WireBox::encode_absent(out);
6668 }
6669
6670 Ok(())
6671 }
6672 }
6673
6674 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
6675 for DictionaryDrainIteratorGetNextResponse
6676 {
6677 #[inline]
6678 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
6679 Self {
6680 items: ::fidl_next::FromWire::from_wire(wire.items),
6681
6682 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
6683 }
6684 }
6685 }
6686
6687 #[derive(PartialEq, Clone, Debug)]
6688 pub struct DictionaryEnumerateIteratorGetNextRequest {
6689 pub start_id: u64,
6690
6691 pub limit: u32,
6692 }
6693
6694 impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest {
6695 type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
6696 }
6697
6698 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextRequest
6699 where
6700 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6701 {
6702 #[inline]
6703 fn encode(
6704 self,
6705 encoder_: &mut ___E,
6706 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6707 _: (),
6708 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6709 ::fidl_next::munge! {
6710 let Self::Encoded {
6711 start_id,
6712 limit,
6713
6714 } = out_;
6715 }
6716
6717 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
6718
6719 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6720
6721 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
6722
6723 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6724
6725 Ok(())
6726 }
6727 }
6728
6729 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryEnumerateIteratorGetNextRequest
6730 where
6731 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6732 {
6733 #[inline]
6734 fn encode_ref(
6735 &self,
6736 encoder_: &mut ___E,
6737 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6738 _: (),
6739 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6740 ::fidl_next::munge! {
6741 let Self::Encoded {
6742
6743 start_id,
6744 limit,
6745
6746 } = out_;
6747 }
6748
6749 ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id, ())?;
6750
6751 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6752
6753 ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit, ())?;
6754
6755 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6756
6757 Ok(())
6758 }
6759 }
6760
6761 impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextRequest {
6762 type EncodedOption =
6763 ::fidl_next::WireBox<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>;
6764 }
6765
6766 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextRequest
6767 where
6768 ___E: ::fidl_next::Encoder + ?Sized,
6769 DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Encode<___E>,
6770 {
6771 #[inline]
6772 fn encode_option(
6773 this: ::core::option::Option<Self>,
6774 encoder: &mut ___E,
6775 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6776 _: (),
6777 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6778 if let Some(inner) = this {
6779 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6780 ::fidl_next::WireBox::encode_present(out);
6781 } else {
6782 ::fidl_next::WireBox::encode_absent(out);
6783 }
6784
6785 Ok(())
6786 }
6787 }
6788
6789 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryEnumerateIteratorGetNextRequest
6790 where
6791 ___E: ::fidl_next::Encoder + ?Sized,
6792 DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
6793 {
6794 #[inline]
6795 fn encode_option_ref(
6796 this: ::core::option::Option<&Self>,
6797 encoder: &mut ___E,
6798 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6799 _: (),
6800 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6801 if let Some(inner) = this {
6802 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6803 ::fidl_next::WireBox::encode_present(out);
6804 } else {
6805 ::fidl_next::WireBox::encode_absent(out);
6806 }
6807
6808 Ok(())
6809 }
6810 }
6811
6812 impl ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
6813 for DictionaryEnumerateIteratorGetNextRequest
6814 {
6815 #[inline]
6816 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
6817 Self {
6818 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
6819
6820 limit: ::fidl_next::FromWire::from_wire(wire.limit),
6821 }
6822 }
6823 }
6824
6825 impl ::fidl_next::FromWireRef<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
6826 for DictionaryEnumerateIteratorGetNextRequest
6827 {
6828 #[inline]
6829 fn from_wire_ref(wire: &crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
6830 Self {
6831 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
6832
6833 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
6834 }
6835 }
6836 }
6837
6838 #[doc = " A key-value pair in a [`DictionaryRef`], where the value may be elided.\n This is useful for APIs that may wish to omit the value, for example if it could not be\n duplicated.\n"]
6839 #[derive(PartialEq, Debug)]
6840 pub struct DictionaryOptionalItem {
6841 pub key: ::std::string::String,
6842
6843 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
6844 }
6845
6846 impl ::fidl_next::Encodable for DictionaryOptionalItem {
6847 type Encoded = crate::wire::DictionaryOptionalItem<'static>;
6848 }
6849
6850 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryOptionalItem
6851 where
6852 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6853 ___E: ::fidl_next::Encoder,
6854 ___E: ::fidl_next::fuchsia::HandleEncoder,
6855 {
6856 #[inline]
6857 fn encode(
6858 self,
6859 encoder_: &mut ___E,
6860 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6861 _: (),
6862 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6863 ::fidl_next::munge! {
6864 let Self::Encoded {
6865 key,
6866 value,
6867
6868 } = out_;
6869 }
6870
6871 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
6872
6873 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
6874 ::fidl_next::Constrained::validate(_field, 255)?;
6875
6876 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
6877
6878 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
6879
6880 Ok(())
6881 }
6882 }
6883
6884 impl ::fidl_next::EncodableOption for DictionaryOptionalItem {
6885 type EncodedOption =
6886 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>;
6887 }
6888
6889 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryOptionalItem
6890 where
6891 ___E: ::fidl_next::Encoder + ?Sized,
6892 DictionaryOptionalItem: ::fidl_next::Encode<___E>,
6893 {
6894 #[inline]
6895 fn encode_option(
6896 this: ::core::option::Option<Self>,
6897 encoder: &mut ___E,
6898 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6899 _: (),
6900 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6901 if let Some(inner) = this {
6902 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6903 ::fidl_next::WireBox::encode_present(out);
6904 } else {
6905 ::fidl_next::WireBox::encode_absent(out);
6906 }
6907
6908 Ok(())
6909 }
6910 }
6911
6912 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
6913 for DictionaryOptionalItem
6914 {
6915 #[inline]
6916 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
6917 Self {
6918 key: ::fidl_next::FromWire::from_wire(wire.key),
6919
6920 value: ::fidl_next::FromWire::from_wire(wire.value),
6921 }
6922 }
6923 }
6924
6925 #[derive(PartialEq, Debug)]
6926 pub struct DictionaryEnumerateIteratorGetNextResponse {
6927 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
6928
6929 pub end_id: u64,
6930 }
6931
6932 impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse {
6933 type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>;
6934 }
6935
6936 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextResponse
6937 where
6938 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6939 ___E: ::fidl_next::Encoder,
6940 ___E: ::fidl_next::fuchsia::HandleEncoder,
6941 {
6942 #[inline]
6943 fn encode(
6944 self,
6945 encoder_: &mut ___E,
6946 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6947 _: (),
6948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6949 ::fidl_next::munge! {
6950 let Self::Encoded {
6951 items,
6952 end_id,
6953
6954 } = out_;
6955 }
6956
6957 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
6958
6959 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
6960 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6961
6962 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
6963
6964 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
6965
6966 Ok(())
6967 }
6968 }
6969
6970 impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextResponse {
6971 type EncodedOption = ::fidl_next::WireBox<
6972 'static,
6973 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
6974 >;
6975 }
6976
6977 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextResponse
6978 where
6979 ___E: ::fidl_next::Encoder + ?Sized,
6980 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<___E>,
6981 {
6982 #[inline]
6983 fn encode_option(
6984 this: ::core::option::Option<Self>,
6985 encoder: &mut ___E,
6986 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6987 _: (),
6988 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6989 if let Some(inner) = this {
6990 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6991 ::fidl_next::WireBox::encode_present(out);
6992 } else {
6993 ::fidl_next::WireBox::encode_absent(out);
6994 }
6995
6996 Ok(())
6997 }
6998 }
6999
7000 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
7001 for DictionaryEnumerateIteratorGetNextResponse
7002 {
7003 #[inline]
7004 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
7005 Self {
7006 items: ::fidl_next::FromWire::from_wire(wire.items),
7007
7008 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
7009 }
7010 }
7011 }
7012
7013 #[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
7014 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7015 #[repr(u32)]
7016 pub enum DictionaryError {
7017 NotFound = 1,
7018 AlreadyExists = 2,
7019 BadCapability = 3,
7020 InvalidKey = 4,
7021 NotCloneable = 5,
7022 UnknownOrdinal_(u32) = 6,
7023 }
7024
7025 impl ::fidl_next::Encodable for DictionaryError {
7026 type Encoded = crate::wire::DictionaryError;
7027 }
7028 impl ::std::convert::From<u32> for DictionaryError {
7029 fn from(value: u32) -> Self {
7030 match value {
7031 1 => Self::NotFound,
7032 2 => Self::AlreadyExists,
7033 3 => Self::BadCapability,
7034 4 => Self::InvalidKey,
7035 5 => Self::NotCloneable,
7036
7037 _ => Self::UnknownOrdinal_(value),
7038 }
7039 }
7040 }
7041
7042 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryError
7043 where
7044 ___E: ?Sized,
7045 {
7046 #[inline]
7047 fn encode(
7048 self,
7049 encoder: &mut ___E,
7050 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7051 _: (),
7052 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7053 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
7054 }
7055 }
7056
7057 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryError
7058 where
7059 ___E: ?Sized,
7060 {
7061 #[inline]
7062 fn encode_ref(
7063 &self,
7064 encoder: &mut ___E,
7065 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7066 _: (),
7067 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7068 ::fidl_next::munge!(let crate::wire::DictionaryError { value } = out);
7069 let _ = value.write(::fidl_next::WireU32::from(match *self {
7070 Self::NotFound => 1,
7071
7072 Self::AlreadyExists => 2,
7073
7074 Self::BadCapability => 3,
7075
7076 Self::InvalidKey => 4,
7077
7078 Self::NotCloneable => 5,
7079
7080 Self::UnknownOrdinal_(value) => value,
7081 }));
7082
7083 Ok(())
7084 }
7085 }
7086
7087 impl ::core::convert::From<crate::wire::DictionaryError> for DictionaryError {
7088 fn from(wire: crate::wire::DictionaryError) -> Self {
7089 match u32::from(wire.value) {
7090 1 => Self::NotFound,
7091
7092 2 => Self::AlreadyExists,
7093
7094 3 => Self::BadCapability,
7095
7096 4 => Self::InvalidKey,
7097
7098 5 => Self::NotCloneable,
7099
7100 value => Self::UnknownOrdinal_(value),
7101 }
7102 }
7103 }
7104
7105 impl ::fidl_next::FromWire<crate::wire::DictionaryError> for DictionaryError {
7106 #[inline]
7107 fn from_wire(wire: crate::wire::DictionaryError) -> Self {
7108 Self::from(wire)
7109 }
7110 }
7111
7112 impl ::fidl_next::FromWireRef<crate::wire::DictionaryError> for DictionaryError {
7113 #[inline]
7114 fn from_wire_ref(wire: &crate::wire::DictionaryError) -> Self {
7115 Self::from(*wire)
7116 }
7117 }
7118
7119 #[derive(PartialEq, Debug)]
7120 pub struct DictionaryKeysIteratorGetNextResponse {
7121 pub keys: ::std::vec::Vec<::std::string::String>,
7122 }
7123
7124 impl ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse {
7125 type Encoded = crate::wire::DictionaryKeysIteratorGetNextResponse<'static>;
7126 }
7127
7128 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse
7129 where
7130 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7131 ___E: ::fidl_next::Encoder,
7132 ___E: ::fidl_next::fuchsia::HandleEncoder,
7133 {
7134 #[inline]
7135 fn encode(
7136 self,
7137 encoder_: &mut ___E,
7138 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7139 _: (),
7140 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7141 ::fidl_next::munge! {
7142 let Self::Encoded {
7143 keys,
7144
7145 } = out_;
7146 }
7147
7148 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
7149
7150 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
7151 ::fidl_next::Constrained::validate(_field, (128, 255))?;
7152
7153 Ok(())
7154 }
7155 }
7156
7157 impl ::fidl_next::EncodableOption for DictionaryKeysIteratorGetNextResponse {
7158 type EncodedOption = ::fidl_next::WireBox<
7159 'static,
7160 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
7161 >;
7162 }
7163
7164 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryKeysIteratorGetNextResponse
7165 where
7166 ___E: ::fidl_next::Encoder + ?Sized,
7167 DictionaryKeysIteratorGetNextResponse: ::fidl_next::Encode<___E>,
7168 {
7169 #[inline]
7170 fn encode_option(
7171 this: ::core::option::Option<Self>,
7172 encoder: &mut ___E,
7173 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7174 _: (),
7175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7176 if let Some(inner) = this {
7177 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7178 ::fidl_next::WireBox::encode_present(out);
7179 } else {
7180 ::fidl_next::WireBox::encode_absent(out);
7181 }
7182
7183 Ok(())
7184 }
7185 }
7186
7187 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
7188 for DictionaryKeysIteratorGetNextResponse
7189 {
7190 #[inline]
7191 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
7192 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
7193 }
7194 }
7195
7196 #[derive(PartialEq, Debug)]
7197 pub enum DictionaryRouterRouteResponse {
7198 Dictionary(crate::natural::DictionaryRef),
7199
7200 Unavailable(crate::natural::Unit),
7201 }
7202
7203 impl ::fidl_next::Encodable for DictionaryRouterRouteResponse {
7204 type Encoded = crate::wire::DictionaryRouterRouteResponse;
7205 }
7206
7207 unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRouterRouteResponse
7208 where
7209 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7210 ___E: ::fidl_next::fuchsia::HandleEncoder,
7211 {
7212 #[inline]
7213 fn encode(
7214 self,
7215 encoder: &mut ___E,
7216 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7217 _: (),
7218 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7219 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
7220
7221 match self {
7222 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7223 ___E,
7224 crate::natural::DictionaryRef,
7225 >(value, 1, encoder, raw, ())?,
7226
7227 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7228 ___E,
7229 crate::natural::Unit,
7230 >(value, 2, encoder, raw, ())?,
7231 }
7232
7233 Ok(())
7234 }
7235 }
7236
7237 impl ::fidl_next::EncodableOption for DictionaryRouterRouteResponse {
7238 type EncodedOption = crate::wire_optional::DictionaryRouterRouteResponse;
7239 }
7240
7241 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRouterRouteResponse
7242 where
7243 ___E: ?Sized,
7244 DictionaryRouterRouteResponse: ::fidl_next::Encode<___E>,
7245 {
7246 #[inline]
7247 fn encode_option(
7248 this: ::core::option::Option<Self>,
7249 encoder: &mut ___E,
7250 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7251 _: (),
7252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7253 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7254
7255 if let Some(inner) = this {
7256 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7257 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7258 } else {
7259 ::fidl_next::RawWireUnion::encode_absent(raw);
7260 }
7261
7262 Ok(())
7263 }
7264 }
7265
7266 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
7267 for DictionaryRouterRouteResponse
7268 {
7269 #[inline]
7270 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
7271 let wire = ::core::mem::ManuallyDrop::new(wire);
7272 match wire.raw.ordinal() {
7273 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
7274 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
7275 })),
7276
7277 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7278 wire.raw.get().read_unchecked::<crate::wire::Unit>()
7279 })),
7280
7281 _ => unsafe { ::core::hint::unreachable_unchecked() },
7282 }
7283 }
7284 }
7285
7286 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
7287 for DictionaryRouterRouteResponse
7288 {
7289 #[inline]
7290 fn from_wire_option(
7291 wire: crate::wire_optional::DictionaryRouterRouteResponse,
7292 ) -> ::core::option::Option<Self> {
7293 if let Some(inner) = wire.into_option() {
7294 Some(::fidl_next::FromWire::from_wire(inner))
7295 } else {
7296 None
7297 }
7298 }
7299 }
7300
7301 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
7302 for Box<DictionaryRouterRouteResponse>
7303 {
7304 #[inline]
7305 fn from_wire_option(
7306 wire: crate::wire_optional::DictionaryRouterRouteResponse,
7307 ) -> ::core::option::Option<Self> {
7308 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
7309 crate::wire_optional::DictionaryRouterRouteResponse,
7310 >>::from_wire_option(wire)
7311 .map(Box::new)
7312 }
7313 }
7314
7315 #[derive(PartialEq, Debug)]
7316 pub enum DirConnectorRouterRouteResponse {
7317 DirConnector(crate::natural::DirConnector),
7318
7319 Unavailable(crate::natural::Unit),
7320 }
7321
7322 impl ::fidl_next::Encodable for DirConnectorRouterRouteResponse {
7323 type Encoded = crate::wire::DirConnectorRouterRouteResponse;
7324 }
7325
7326 unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnectorRouterRouteResponse
7327 where
7328 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7329 ___E: ::fidl_next::fuchsia::HandleEncoder,
7330 {
7331 #[inline]
7332 fn encode(
7333 self,
7334 encoder: &mut ___E,
7335 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7336 _: (),
7337 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7338 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
7339
7340 match self {
7341 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7342 ___E,
7343 crate::natural::DirConnector,
7344 >(value, 1, encoder, raw, ())?,
7345
7346 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7347 ___E,
7348 crate::natural::Unit,
7349 >(value, 2, encoder, raw, ())?,
7350 }
7351
7352 Ok(())
7353 }
7354 }
7355
7356 impl ::fidl_next::EncodableOption for DirConnectorRouterRouteResponse {
7357 type EncodedOption = crate::wire_optional::DirConnectorRouterRouteResponse;
7358 }
7359
7360 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnectorRouterRouteResponse
7361 where
7362 ___E: ?Sized,
7363 DirConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
7364 {
7365 #[inline]
7366 fn encode_option(
7367 this: ::core::option::Option<Self>,
7368 encoder: &mut ___E,
7369 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7370 _: (),
7371 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7372 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7373
7374 if let Some(inner) = this {
7375 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7376 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7377 } else {
7378 ::fidl_next::RawWireUnion::encode_absent(raw);
7379 }
7380
7381 Ok(())
7382 }
7383 }
7384
7385 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
7386 for DirConnectorRouterRouteResponse
7387 {
7388 #[inline]
7389 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
7390 let wire = ::core::mem::ManuallyDrop::new(wire);
7391 match wire.raw.ordinal() {
7392 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
7393 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
7394 })),
7395
7396 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7397 wire.raw.get().read_unchecked::<crate::wire::Unit>()
7398 })),
7399
7400 _ => unsafe { ::core::hint::unreachable_unchecked() },
7401 }
7402 }
7403 }
7404
7405 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
7406 for DirConnectorRouterRouteResponse
7407 {
7408 #[inline]
7409 fn from_wire_option(
7410 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
7411 ) -> ::core::option::Option<Self> {
7412 if let Some(inner) = wire.into_option() {
7413 Some(::fidl_next::FromWire::from_wire(inner))
7414 } else {
7415 None
7416 }
7417 }
7418 }
7419
7420 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
7421 for Box<DirConnectorRouterRouteResponse>
7422 {
7423 #[inline]
7424 fn from_wire_option(
7425 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
7426 ) -> ::core::option::Option<Self> {
7427 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
7428 crate::wire_optional::DirConnectorRouterRouteResponse,
7429 >>::from_wire_option(wire)
7430 .map(Box::new)
7431 }
7432 }
7433
7434 #[derive(PartialEq, Debug)]
7435 pub enum DirEntryRouterRouteResponse {
7436 DirEntry(crate::natural::DirEntry),
7437
7438 Unavailable(crate::natural::Unit),
7439 }
7440
7441 impl ::fidl_next::Encodable for DirEntryRouterRouteResponse {
7442 type Encoded = crate::wire::DirEntryRouterRouteResponse;
7443 }
7444
7445 unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntryRouterRouteResponse
7446 where
7447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7448 ___E: ::fidl_next::fuchsia::HandleEncoder,
7449 {
7450 #[inline]
7451 fn encode(
7452 self,
7453 encoder: &mut ___E,
7454 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7455 _: (),
7456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7457 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
7458
7459 match self {
7460 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7461 ___E,
7462 crate::natural::DirEntry,
7463 >(value, 1, encoder, raw, ())?,
7464
7465 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7466 ___E,
7467 crate::natural::Unit,
7468 >(value, 2, encoder, raw, ())?,
7469 }
7470
7471 Ok(())
7472 }
7473 }
7474
7475 impl ::fidl_next::EncodableOption for DirEntryRouterRouteResponse {
7476 type EncodedOption = crate::wire_optional::DirEntryRouterRouteResponse;
7477 }
7478
7479 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntryRouterRouteResponse
7480 where
7481 ___E: ?Sized,
7482 DirEntryRouterRouteResponse: ::fidl_next::Encode<___E>,
7483 {
7484 #[inline]
7485 fn encode_option(
7486 this: ::core::option::Option<Self>,
7487 encoder: &mut ___E,
7488 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7489 _: (),
7490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7491 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7492
7493 if let Some(inner) = this {
7494 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7495 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7496 } else {
7497 ::fidl_next::RawWireUnion::encode_absent(raw);
7498 }
7499
7500 Ok(())
7501 }
7502 }
7503
7504 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
7505 for DirEntryRouterRouteResponse
7506 {
7507 #[inline]
7508 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
7509 let wire = ::core::mem::ManuallyDrop::new(wire);
7510 match wire.raw.ordinal() {
7511 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
7512 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
7513 })),
7514
7515 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7516 wire.raw.get().read_unchecked::<crate::wire::Unit>()
7517 })),
7518
7519 _ => unsafe { ::core::hint::unreachable_unchecked() },
7520 }
7521 }
7522 }
7523
7524 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
7525 for DirEntryRouterRouteResponse
7526 {
7527 #[inline]
7528 fn from_wire_option(
7529 wire: crate::wire_optional::DirEntryRouterRouteResponse,
7530 ) -> ::core::option::Option<Self> {
7531 if let Some(inner) = wire.into_option() {
7532 Some(::fidl_next::FromWire::from_wire(inner))
7533 } else {
7534 None
7535 }
7536 }
7537 }
7538
7539 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
7540 for Box<DirEntryRouterRouteResponse>
7541 {
7542 #[inline]
7543 fn from_wire_option(
7544 wire: crate::wire_optional::DirEntryRouterRouteResponse,
7545 ) -> ::core::option::Option<Self> {
7546 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
7547 crate::wire_optional::DirEntryRouterRouteResponse,
7548 >>::from_wire_option(wire)
7549 .map(Box::new)
7550 }
7551 }
7552
7553 #[derive(PartialEq, Debug)]
7554 #[repr(C)]
7555 pub struct DirReceiverReceiveRequest {
7556 pub channel: ::fidl_next::ServerEnd<
7557 ::fidl_next_fuchsia_io::Directory,
7558 ::fidl_next::fuchsia::zx::Channel,
7559 >,
7560 }
7561
7562 impl ::fidl_next::Encodable for DirReceiverReceiveRequest {
7563 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7564 Self,
7565 crate::wire::DirReceiverReceiveRequest,
7566 > = unsafe {
7567 ::fidl_next::CopyOptimization::enable_if(
7568 true && <::fidl_next::ServerEnd<
7569 ::fidl_next_fuchsia_io::Directory,
7570 ::fidl_next::fuchsia::zx::Channel,
7571 > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
7572 .is_enabled(),
7573 )
7574 };
7575
7576 type Encoded = crate::wire::DirReceiverReceiveRequest;
7577 }
7578
7579 unsafe impl<___E> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest
7580 where
7581 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7582 ___E: ::fidl_next::fuchsia::HandleEncoder,
7583 {
7584 #[inline]
7585 fn encode(
7586 self,
7587 encoder_: &mut ___E,
7588 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7589 _: (),
7590 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7591 ::fidl_next::munge! {
7592 let Self::Encoded {
7593 channel,
7594
7595 } = out_;
7596 }
7597
7598 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7599
7600 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
7601
7602 Ok(())
7603 }
7604 }
7605
7606 impl ::fidl_next::EncodableOption for DirReceiverReceiveRequest {
7607 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirReceiverReceiveRequest>;
7608 }
7609
7610 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirReceiverReceiveRequest
7611 where
7612 ___E: ::fidl_next::Encoder + ?Sized,
7613 DirReceiverReceiveRequest: ::fidl_next::Encode<___E>,
7614 {
7615 #[inline]
7616 fn encode_option(
7617 this: ::core::option::Option<Self>,
7618 encoder: &mut ___E,
7619 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7620 _: (),
7621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7622 if let Some(inner) = this {
7623 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7624 ::fidl_next::WireBox::encode_present(out);
7625 } else {
7626 ::fidl_next::WireBox::encode_absent(out);
7627 }
7628
7629 Ok(())
7630 }
7631 }
7632
7633 impl ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest> for DirReceiverReceiveRequest {
7634 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7635 crate::wire::DirReceiverReceiveRequest,
7636 Self,
7637 > = unsafe {
7638 ::fidl_next::CopyOptimization::enable_if(
7639 true && <::fidl_next::ServerEnd<
7640 ::fidl_next_fuchsia_io::Directory,
7641 ::fidl_next::fuchsia::zx::Channel,
7642 > as ::fidl_next::FromWire<
7643 ::fidl_next::ServerEnd<
7644 ::fidl_next_fuchsia_io::Directory,
7645 ::fidl_next::fuchsia::WireChannel,
7646 >,
7647 >>::COPY_OPTIMIZATION
7648 .is_enabled(),
7649 )
7650 };
7651
7652 #[inline]
7653 fn from_wire(wire: crate::wire::DirReceiverReceiveRequest) -> Self {
7654 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
7655 }
7656 }
7657
7658 #[derive(PartialEq, Debug)]
7659 pub enum DirectoryRouterRouteResponse {
7660 Directory(
7661 ::fidl_next::ClientEnd<
7662 ::fidl_next_fuchsia_io::Directory,
7663 ::fidl_next::fuchsia::zx::Channel,
7664 >,
7665 ),
7666
7667 Unavailable(crate::natural::Unit),
7668 }
7669
7670 impl ::fidl_next::Encodable for DirectoryRouterRouteResponse {
7671 type Encoded = crate::wire::DirectoryRouterRouteResponse;
7672 }
7673
7674 unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRouterRouteResponse
7675 where
7676 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7677 ___E: ::fidl_next::fuchsia::HandleEncoder,
7678 {
7679 #[inline]
7680 fn encode(
7681 self,
7682 encoder: &mut ___E,
7683 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7684 _: (),
7685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7686 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
7687
7688 match self {
7689 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7690 ___E,
7691 ::fidl_next::ClientEnd<
7692 ::fidl_next_fuchsia_io::Directory,
7693 ::fidl_next::fuchsia::zx::Channel,
7694 >,
7695 >(value, 1, encoder, raw, ())?,
7696
7697 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7698 ___E,
7699 crate::natural::Unit,
7700 >(value, 2, encoder, raw, ())?,
7701 }
7702
7703 Ok(())
7704 }
7705 }
7706
7707 impl ::fidl_next::EncodableOption for DirectoryRouterRouteResponse {
7708 type EncodedOption = crate::wire_optional::DirectoryRouterRouteResponse;
7709 }
7710
7711 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRouterRouteResponse
7712 where
7713 ___E: ?Sized,
7714 DirectoryRouterRouteResponse: ::fidl_next::Encode<___E>,
7715 {
7716 #[inline]
7717 fn encode_option(
7718 this: ::core::option::Option<Self>,
7719 encoder: &mut ___E,
7720 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7721 _: (),
7722 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7723 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7724
7725 if let Some(inner) = this {
7726 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7727 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7728 } else {
7729 ::fidl_next::RawWireUnion::encode_absent(raw);
7730 }
7731
7732 Ok(())
7733 }
7734 }
7735
7736 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
7737 for DirectoryRouterRouteResponse
7738 {
7739 #[inline]
7740 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
7741 let wire = ::core::mem::ManuallyDrop::new(wire);
7742 match wire.raw.ordinal() {
7743 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
7744 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
7745 ::fidl_next_fuchsia_io::Directory,
7746 ::fidl_next::fuchsia::WireChannel,
7747 >>()
7748 })),
7749
7750 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7751 wire.raw.get().read_unchecked::<crate::wire::Unit>()
7752 })),
7753
7754 _ => unsafe { ::core::hint::unreachable_unchecked() },
7755 }
7756 }
7757 }
7758
7759 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
7760 for DirectoryRouterRouteResponse
7761 {
7762 #[inline]
7763 fn from_wire_option(
7764 wire: crate::wire_optional::DirectoryRouterRouteResponse,
7765 ) -> ::core::option::Option<Self> {
7766 if let Some(inner) = wire.into_option() {
7767 Some(::fidl_next::FromWire::from_wire(inner))
7768 } else {
7769 None
7770 }
7771 }
7772 }
7773
7774 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
7775 for Box<DirectoryRouterRouteResponse>
7776 {
7777 #[inline]
7778 fn from_wire_option(
7779 wire: crate::wire_optional::DirectoryRouterRouteResponse,
7780 ) -> ::core::option::Option<Self> {
7781 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
7782 crate::wire_optional::DirectoryRouterRouteResponse,
7783 >>::from_wire_option(wire)
7784 .map(Box::new)
7785 }
7786 }
7787
7788 #[doc = " Contains a protocol open request.\n"]
7789 #[derive(PartialEq, Debug)]
7790 #[repr(C)]
7791 pub struct ProtocolPayload {
7792 pub channel: ::fidl_next::fuchsia::zx::Channel,
7793 }
7794
7795 impl ::fidl_next::Encodable for ProtocolPayload {
7796 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
7797 ::fidl_next::CopyOptimization::enable_if(
7798 true
7799
7800 && <
7801 ::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encodable
7802 >::COPY_OPTIMIZATION.is_enabled()
7803
7804 )
7805 };
7806
7807 type Encoded = crate::wire::ProtocolPayload;
7808 }
7809
7810 unsafe impl<___E> ::fidl_next::Encode<___E> for ProtocolPayload
7811 where
7812 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7813 ___E: ::fidl_next::fuchsia::HandleEncoder,
7814 {
7815 #[inline]
7816 fn encode(
7817 self,
7818 encoder_: &mut ___E,
7819 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7820 _: (),
7821 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7822 ::fidl_next::munge! {
7823 let Self::Encoded {
7824 channel,
7825
7826 } = out_;
7827 }
7828
7829 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7830
7831 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
7832
7833 Ok(())
7834 }
7835 }
7836
7837 impl ::fidl_next::EncodableOption for ProtocolPayload {
7838 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>;
7839 }
7840
7841 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ProtocolPayload
7842 where
7843 ___E: ::fidl_next::Encoder + ?Sized,
7844 ProtocolPayload: ::fidl_next::Encode<___E>,
7845 {
7846 #[inline]
7847 fn encode_option(
7848 this: ::core::option::Option<Self>,
7849 encoder: &mut ___E,
7850 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7851 _: (),
7852 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7853 if let Some(inner) = this {
7854 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7855 ::fidl_next::WireBox::encode_present(out);
7856 } else {
7857 ::fidl_next::WireBox::encode_absent(out);
7858 }
7859
7860 Ok(())
7861 }
7862 }
7863
7864 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
7865 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
7866 ::fidl_next::CopyOptimization::enable_if(
7867 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
7868 ::fidl_next::fuchsia::WireChannel,
7869 >>::COPY_OPTIMIZATION
7870 .is_enabled(),
7871 )
7872 };
7873
7874 #[inline]
7875 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
7876 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
7877 }
7878 }
7879
7880 #[derive(PartialEq, Clone, Debug)]
7881 #[repr(C)]
7882 pub struct Unavailable {}
7883
7884 impl ::fidl_next::Encodable for Unavailable {
7885 type Encoded = crate::wire::Unavailable;
7886 }
7887
7888 unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
7889 where
7890 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7891 {
7892 #[inline]
7893 fn encode(
7894 self,
7895 encoder_: &mut ___E,
7896 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7897 _: (),
7898 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7899 *out_ = ::core::mem::MaybeUninit::zeroed();
7900
7901 Ok(())
7902 }
7903 }
7904
7905 unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unavailable
7906 where
7907 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7908 {
7909 #[inline]
7910 fn encode_ref(
7911 &self,
7912 encoder_: &mut ___E,
7913 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7914 _: (),
7915 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7916 ::fidl_next::munge! {
7917 let Self::Encoded {
7918
7919 _empty,
7920
7921
7922 } = out_;
7923 }
7924
7925 Ok(())
7926 }
7927 }
7928
7929 impl ::fidl_next::EncodableOption for Unavailable {
7930 type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Unavailable>;
7931 }
7932
7933 unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unavailable
7934 where
7935 ___E: ::fidl_next::Encoder + ?Sized,
7936 Unavailable: ::fidl_next::Encode<___E>,
7937 {
7938 #[inline]
7939 fn encode_option(
7940 this: ::core::option::Option<Self>,
7941 encoder: &mut ___E,
7942 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7943 _: (),
7944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7945 if let Some(inner) = this {
7946 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7947 ::fidl_next::WireBox::encode_present(out);
7948 } else {
7949 ::fidl_next::WireBox::encode_absent(out);
7950 }
7951
7952 Ok(())
7953 }
7954 }
7955
7956 unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unavailable
7957 where
7958 ___E: ::fidl_next::Encoder + ?Sized,
7959 Unavailable: ::fidl_next::EncodeRef<___E>,
7960 {
7961 #[inline]
7962 fn encode_option_ref(
7963 this: ::core::option::Option<&Self>,
7964 encoder: &mut ___E,
7965 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7966 _: (),
7967 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7968 if let Some(inner) = this {
7969 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7970 ::fidl_next::WireBox::encode_present(out);
7971 } else {
7972 ::fidl_next::WireBox::encode_absent(out);
7973 }
7974
7975 Ok(())
7976 }
7977 }
7978
7979 impl ::fidl_next::FromWire<crate::wire::Unavailable> for Unavailable {
7980 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unavailable, Self> =
7981 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
7982
7983 #[inline]
7984 fn from_wire(wire: crate::wire::Unavailable) -> Self {
7985 Self {}
7986 }
7987 }
7988
7989 impl ::fidl_next::FromWireRef<crate::wire::Unavailable> for Unavailable {
7990 #[inline]
7991 fn from_wire_ref(wire: &crate::wire::Unavailable) -> Self {
7992 Self {}
7993 }
7994 }
7995}
7996
7997pub mod wire {
7998
7999 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8001 #[repr(transparent)]
8002 pub struct Availability {
8003 pub(crate) value: ::fidl_next::WireU32,
8004 }
8005
8006 unsafe impl ::fidl_next::Wire for Availability {
8007 type Decoded<'de> = Self;
8008
8009 #[inline]
8010 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8011 }
8013 }
8014
8015 impl Availability {
8016 pub const REQUIRED: Availability = Availability { value: ::fidl_next::WireU32(1) };
8017
8018 pub const OPTIONAL: Availability = Availability { value: ::fidl_next::WireU32(2) };
8019
8020 pub const SAME_AS_TARGET: Availability = Availability { value: ::fidl_next::WireU32(3) };
8021
8022 pub const TRANSITIONAL: Availability = Availability { value: ::fidl_next::WireU32(4) };
8023 }
8024
8025 unsafe impl<___D> ::fidl_next::Decode<___D> for Availability
8026 where
8027 ___D: ?Sized,
8028 {
8029 fn decode(
8030 slot: ::fidl_next::Slot<'_, Self>,
8031 _: &mut ___D,
8032 _: (),
8033 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8034 ::fidl_next::munge!(let Self { value } = slot);
8035
8036 match u32::from(*value) {
8037 1 | 2 | 3 | 4 => (),
8038 unknown => {
8039 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
8040 }
8041 }
8042
8043 Ok(())
8044 }
8045 }
8046
8047 impl ::core::convert::From<crate::natural::Availability> for Availability {
8048 fn from(natural: crate::natural::Availability) -> Self {
8049 match natural {
8050 crate::natural::Availability::Required => Availability::REQUIRED,
8051
8052 crate::natural::Availability::Optional => Availability::OPTIONAL,
8053
8054 crate::natural::Availability::SameAsTarget => Availability::SAME_AS_TARGET,
8055
8056 crate::natural::Availability::Transitional => Availability::TRANSITIONAL,
8057 }
8058 }
8059 }
8060
8061 impl ::fidl_next::IntoNatural for Availability {
8062 type Natural = crate::natural::Availability;
8063 }
8064
8065 impl ::fidl_next::Unconstrained for Availability {}
8066
8067 #[derive(Clone, Debug)]
8069 #[repr(C)]
8070 pub struct Unit {
8071 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
8072 }
8073
8074 static_assertions::const_assert_eq!(std::mem::size_of::<Unit>(), 1);
8075 static_assertions::const_assert_eq!(std::mem::align_of::<Unit>(), 1);
8076
8077 unsafe impl ::fidl_next::Wire for Unit {
8078 type Decoded<'de> = Unit;
8079
8080 #[inline]
8081 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8082 ::fidl_next::munge! {
8083 let Self {
8084
8085 _empty,
8086
8087
8088 } = &mut *out_;
8089 }
8090 }
8091 }
8092
8093 unsafe impl<___D> ::fidl_next::Decode<___D> for Unit
8094 where
8095 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8096 {
8097 fn decode(
8098 slot_: ::fidl_next::Slot<'_, Self>,
8099 decoder_: &mut ___D,
8100 _: (),
8101 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8102 ::fidl_next::munge! {
8103 let Self {
8104
8105 mut _empty,
8106
8107
8108 } = slot_;
8109 }
8110
8111 if _empty.as_bytes() != &[0u8] {
8112 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
8113 }
8114
8115 Ok(())
8116 }
8117 }
8118
8119 impl ::fidl_next::IntoNatural for Unit {
8120 type Natural = crate::natural::Unit;
8121 }
8122
8123 impl ::fidl_next::Unconstrained for Unit {}
8124
8125 #[repr(transparent)]
8127 pub struct Data<'de> {
8128 pub(crate) raw: ::fidl_next::RawWireUnion,
8129 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8130 }
8131
8132 impl<'de> Drop for Data<'de> {
8133 fn drop(&mut self) {
8134 match self.raw.ordinal() {
8135 1 => {
8136 let _ = unsafe {
8137 self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
8138 };
8139 }
8140
8141 2 => {
8142 let _ =
8143 unsafe { self.raw.get().read_unchecked::<::fidl_next::WireString<'de>>() };
8144 }
8145
8146 3 => {
8147 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI64>() };
8148 }
8149
8150 4 => {
8151 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU64>() };
8152 }
8153
8154 _ => (),
8155 }
8156 }
8157 }
8158
8159 unsafe impl ::fidl_next::Wire for Data<'static> {
8160 type Decoded<'de> = Data<'de>;
8161
8162 #[inline]
8163 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8164 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8165 ::fidl_next::RawWireUnion::zero_padding(raw);
8166 }
8167 }
8168
8169 pub mod data {
8170 pub enum Ref<'de> {
8171 Bytes(&'de ::fidl_next::WireVector<'de, u8>),
8172
8173 String(&'de ::fidl_next::WireString<'de>),
8174
8175 Int64(&'de ::fidl_next::WireI64),
8176
8177 Uint64(&'de ::fidl_next::WireU64),
8178
8179 UnknownOrdinal_(u64),
8180 }
8181 }
8182
8183 impl<'de> Data<'de> {
8184 pub fn as_ref(&self) -> crate::wire::data::Ref<'_> {
8185 match self.raw.ordinal() {
8186 1 => crate::wire::data::Ref::Bytes(unsafe {
8187 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
8188 }),
8189
8190 2 => crate::wire::data::Ref::String(unsafe {
8191 self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
8192 }),
8193
8194 3 => crate::wire::data::Ref::Int64(unsafe {
8195 self.raw.get().deref_unchecked::<::fidl_next::WireI64>()
8196 }),
8197
8198 4 => crate::wire::data::Ref::Uint64(unsafe {
8199 self.raw.get().deref_unchecked::<::fidl_next::WireU64>()
8200 }),
8201
8202 unknown => crate::wire::data::Ref::UnknownOrdinal_(unknown),
8203 }
8204 }
8205 }
8206
8207 unsafe impl<___D> ::fidl_next::Decode<___D> for Data<'static>
8208 where
8209 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8210 ___D: ::fidl_next::Decoder,
8211 {
8212 fn decode(
8213 mut slot: ::fidl_next::Slot<'_, Self>,
8214 decoder: &mut ___D,
8215 _: (),
8216 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8217 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8218 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
8219 1 => ::fidl_next::RawWireUnion::decode_as::<
8220 ___D,
8221 ::fidl_next::WireVector<'static, u8>,
8222 >(raw, decoder, (8192, ()))?,
8223
8224 2 => {
8225 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
8226 raw, decoder, 8192,
8227 )?
8228 }
8229
8230 3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(
8231 raw,
8232 decoder,
8233 (),
8234 )?,
8235
8236 4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(
8237 raw,
8238 decoder,
8239 (),
8240 )?,
8241
8242 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
8243 }
8244
8245 Ok(())
8246 }
8247 }
8248
8249 impl<'de> ::core::fmt::Debug for Data<'de> {
8250 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8251 match self.raw.ordinal() {
8252 1 => unsafe {
8253 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
8254 },
8255 2 => unsafe {
8256 self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f)
8257 },
8258 3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
8259 4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
8260 _ => unsafe { ::core::hint::unreachable_unchecked() },
8261 }
8262 }
8263 }
8264
8265 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
8266 type Natural = crate::natural::Data;
8267 }
8268
8269 impl ::fidl_next::Unconstrained for Data<'static> {}
8270
8271 pub type Token = ::fidl_next::fuchsia::WireEventPair;
8273
8274 #[derive(Debug)]
8276 #[repr(C)]
8277 pub struct DictionaryRef {
8278 pub token: ::fidl_next::fuchsia::WireEventPair,
8279 }
8280
8281 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
8282 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
8283
8284 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
8285
8286 unsafe impl ::fidl_next::Wire for DictionaryRef {
8287 type Decoded<'de> = DictionaryRef;
8288
8289 #[inline]
8290 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8291 ::fidl_next::munge! {
8292 let Self {
8293
8294 token,
8295
8296 } = &mut *out_;
8297 }
8298
8299 ::fidl_next::Wire::zero_padding(token);
8300 }
8301 }
8302
8303 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
8304 where
8305 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8306 ___D: ::fidl_next::fuchsia::HandleDecoder,
8307 {
8308 fn decode(
8309 slot_: ::fidl_next::Slot<'_, Self>,
8310 decoder_: &mut ___D,
8311 _: (),
8312 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8313 ::fidl_next::munge! {
8314 let Self {
8315
8316 mut token,
8317
8318 } = slot_;
8319 }
8320
8321 let _field = token.as_mut();
8322
8323 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8324
8325 Ok(())
8326 }
8327 }
8328
8329 impl ::fidl_next::IntoNatural for DictionaryRef {
8330 type Natural = crate::natural::DictionaryRef;
8331 }
8332
8333 impl ::fidl_next::Unconstrained for DictionaryRef {}
8334
8335 #[derive(Debug)]
8337 #[repr(C)]
8338 pub struct Connector {
8339 pub token: ::fidl_next::fuchsia::WireEventPair,
8340 }
8341
8342 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
8343 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
8344
8345 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
8346
8347 unsafe impl ::fidl_next::Wire for Connector {
8348 type Decoded<'de> = Connector;
8349
8350 #[inline]
8351 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8352 ::fidl_next::munge! {
8353 let Self {
8354
8355 token,
8356
8357 } = &mut *out_;
8358 }
8359
8360 ::fidl_next::Wire::zero_padding(token);
8361 }
8362 }
8363
8364 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
8365 where
8366 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8367 ___D: ::fidl_next::fuchsia::HandleDecoder,
8368 {
8369 fn decode(
8370 slot_: ::fidl_next::Slot<'_, Self>,
8371 decoder_: &mut ___D,
8372 _: (),
8373 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8374 ::fidl_next::munge! {
8375 let Self {
8376
8377 mut token,
8378
8379 } = slot_;
8380 }
8381
8382 let _field = token.as_mut();
8383
8384 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8385
8386 Ok(())
8387 }
8388 }
8389
8390 impl ::fidl_next::IntoNatural for Connector {
8391 type Natural = crate::natural::Connector;
8392 }
8393
8394 impl ::fidl_next::Unconstrained for Connector {}
8395
8396 #[derive(Debug)]
8398 #[repr(C)]
8399 pub struct DirConnector {
8400 pub token: ::fidl_next::fuchsia::WireEventPair,
8401 }
8402
8403 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
8404 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
8405
8406 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
8407
8408 unsafe impl ::fidl_next::Wire for DirConnector {
8409 type Decoded<'de> = DirConnector;
8410
8411 #[inline]
8412 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8413 ::fidl_next::munge! {
8414 let Self {
8415
8416 token,
8417
8418 } = &mut *out_;
8419 }
8420
8421 ::fidl_next::Wire::zero_padding(token);
8422 }
8423 }
8424
8425 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
8426 where
8427 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8428 ___D: ::fidl_next::fuchsia::HandleDecoder,
8429 {
8430 fn decode(
8431 slot_: ::fidl_next::Slot<'_, Self>,
8432 decoder_: &mut ___D,
8433 _: (),
8434 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8435 ::fidl_next::munge! {
8436 let Self {
8437
8438 mut token,
8439
8440 } = slot_;
8441 }
8442
8443 let _field = token.as_mut();
8444
8445 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8446
8447 Ok(())
8448 }
8449 }
8450
8451 impl ::fidl_next::IntoNatural for DirConnector {
8452 type Natural = crate::natural::DirConnector;
8453 }
8454
8455 impl ::fidl_next::Unconstrained for DirConnector {}
8456
8457 #[derive(Debug)]
8459 #[repr(C)]
8460 pub struct DirEntry {
8461 pub token: ::fidl_next::fuchsia::WireEventPair,
8462 }
8463
8464 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
8465 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
8466
8467 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
8468
8469 unsafe impl ::fidl_next::Wire for DirEntry {
8470 type Decoded<'de> = DirEntry;
8471
8472 #[inline]
8473 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8474 ::fidl_next::munge! {
8475 let Self {
8476
8477 token,
8478
8479 } = &mut *out_;
8480 }
8481
8482 ::fidl_next::Wire::zero_padding(token);
8483 }
8484 }
8485
8486 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
8487 where
8488 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8489 ___D: ::fidl_next::fuchsia::HandleDecoder,
8490 {
8491 fn decode(
8492 slot_: ::fidl_next::Slot<'_, Self>,
8493 decoder_: &mut ___D,
8494 _: (),
8495 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8496 ::fidl_next::munge! {
8497 let Self {
8498
8499 mut token,
8500
8501 } = slot_;
8502 }
8503
8504 let _field = token.as_mut();
8505
8506 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8507
8508 Ok(())
8509 }
8510 }
8511
8512 impl ::fidl_next::IntoNatural for DirEntry {
8513 type Natural = crate::natural::DirEntry;
8514 }
8515
8516 impl ::fidl_next::Unconstrained for DirEntry {}
8517
8518 #[repr(transparent)]
8520 pub struct Capability<'de> {
8521 pub(crate) raw: ::fidl_next::RawWireUnion,
8522 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8523 }
8524
8525 impl<'de> Drop for Capability<'de> {
8526 fn drop(&mut self) {
8527 match self.raw.ordinal() {
8528 1 => {
8529 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
8530 }
8531
8532 2 => {
8533 let _ = unsafe {
8534 self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
8535 };
8536 }
8537
8538 3 => {
8539 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
8540 }
8541
8542 4 => {
8543 let _ =
8544 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
8545 }
8546
8547 5 => {
8548 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
8549 }
8550
8551 6 => {
8552 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
8553 }
8554
8555 7 => {
8556 let _ = unsafe {
8557 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8558 ::fidl_next_fuchsia_io::Directory,
8559 ::fidl_next::fuchsia::WireChannel,
8560 >>()
8561 };
8562 }
8563
8564 8 => {
8565 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
8566 }
8567
8568 9 => {
8569 let _ = unsafe {
8570 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8571 crate::ConnectorRouter,
8572 ::fidl_next::fuchsia::WireChannel,
8573 >>()
8574 };
8575 }
8576
8577 10 => {
8578 let _ = unsafe {
8579 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8580 crate::DictionaryRouter,
8581 ::fidl_next::fuchsia::WireChannel,
8582 >>()
8583 };
8584 }
8585
8586 11 => {
8587 let _ = unsafe {
8588 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8589 crate::DirEntryRouter,
8590 ::fidl_next::fuchsia::WireChannel,
8591 >>()
8592 };
8593 }
8594
8595 12 => {
8596 let _ = unsafe {
8597 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8598 crate::DataRouter,
8599 ::fidl_next::fuchsia::WireChannel,
8600 >>()
8601 };
8602 }
8603
8604 13 => {
8605 let _ = unsafe {
8606 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8607 crate::DirConnectorRouter,
8608 ::fidl_next::fuchsia::WireChannel,
8609 >>()
8610 };
8611 }
8612
8613 _ => (),
8614 }
8615 }
8616 }
8617
8618 unsafe impl ::fidl_next::Wire for Capability<'static> {
8619 type Decoded<'de> = Capability<'de>;
8620
8621 #[inline]
8622 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8623 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8624 ::fidl_next::RawWireUnion::zero_padding(raw);
8625 }
8626 }
8627
8628 pub mod capability {
8629 pub enum Ref<'de> {
8630 Unit(&'de crate::wire::Unit),
8631
8632 Handle(&'de ::fidl_next::fuchsia::WireHandle),
8633
8634 Data(&'de crate::wire::Data<'de>),
8635
8636 Dictionary(&'de crate::wire::DictionaryRef),
8637
8638 Connector(&'de crate::wire::Connector),
8639
8640 DirConnector(&'de crate::wire::DirConnector),
8641
8642 Directory(
8643 &'de ::fidl_next::ClientEnd<
8644 ::fidl_next_fuchsia_io::Directory,
8645 ::fidl_next::fuchsia::WireChannel,
8646 >,
8647 ),
8648
8649 DirEntry(&'de crate::wire::DirEntry),
8650
8651 ConnectorRouter(
8652 &'de ::fidl_next::ClientEnd<
8653 crate::ConnectorRouter,
8654 ::fidl_next::fuchsia::WireChannel,
8655 >,
8656 ),
8657
8658 DictionaryRouter(
8659 &'de ::fidl_next::ClientEnd<
8660 crate::DictionaryRouter,
8661 ::fidl_next::fuchsia::WireChannel,
8662 >,
8663 ),
8664
8665 DirEntryRouter(
8666 &'de ::fidl_next::ClientEnd<
8667 crate::DirEntryRouter,
8668 ::fidl_next::fuchsia::WireChannel,
8669 >,
8670 ),
8671
8672 DataRouter(
8673 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
8674 ),
8675
8676 DirConnectorRouter(
8677 &'de ::fidl_next::ClientEnd<
8678 crate::DirConnectorRouter,
8679 ::fidl_next::fuchsia::WireChannel,
8680 >,
8681 ),
8682
8683 UnknownOrdinal_(u64),
8684 }
8685 }
8686
8687 impl<'de> Capability<'de> {
8688 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
8689 match self.raw.ordinal() {
8690 1 => crate::wire::capability::Ref::Unit(unsafe {
8691 self.raw.get().deref_unchecked::<crate::wire::Unit>()
8692 }),
8693
8694 2 => crate::wire::capability::Ref::Handle(unsafe {
8695 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
8696 }),
8697
8698 3 => crate::wire::capability::Ref::Data(unsafe {
8699 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
8700 }),
8701
8702 4 => crate::wire::capability::Ref::Dictionary(unsafe {
8703 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
8704 }),
8705
8706 5 => crate::wire::capability::Ref::Connector(unsafe {
8707 self.raw.get().deref_unchecked::<crate::wire::Connector>()
8708 }),
8709
8710 6 => crate::wire::capability::Ref::DirConnector(unsafe {
8711 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
8712 }),
8713
8714 7 => crate::wire::capability::Ref::Directory(unsafe {
8715 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8716 ::fidl_next_fuchsia_io::Directory,
8717 ::fidl_next::fuchsia::WireChannel,
8718 >>()
8719 }),
8720
8721 8 => crate::wire::capability::Ref::DirEntry(unsafe {
8722 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
8723 }),
8724
8725 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
8726 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8727 crate::ConnectorRouter,
8728 ::fidl_next::fuchsia::WireChannel,
8729 >>()
8730 }),
8731
8732 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
8733 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8734 crate::DictionaryRouter,
8735 ::fidl_next::fuchsia::WireChannel,
8736 >>()
8737 }),
8738
8739 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
8740 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8741 crate::DirEntryRouter,
8742 ::fidl_next::fuchsia::WireChannel,
8743 >>()
8744 }),
8745
8746 12 => crate::wire::capability::Ref::DataRouter(unsafe {
8747 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
8748 }),
8749
8750 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
8751 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8752 crate::DirConnectorRouter,
8753 ::fidl_next::fuchsia::WireChannel,
8754 >>()
8755 }),
8756
8757 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
8758 }
8759 }
8760 }
8761
8762 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
8763 where
8764 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8765 ___D: ::fidl_next::Decoder,
8766 ___D: ::fidl_next::fuchsia::HandleDecoder,
8767 {
8768 fn decode(
8769 mut slot: ::fidl_next::Slot<'_, Self>,
8770 decoder: &mut ___D,
8771 _: (),
8772 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8773 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8774 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
8775 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
8776 raw,
8777 decoder,
8778 (),
8779 )?,
8780
8781 2 => {
8782 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
8783 raw,
8784 decoder,
8785 (),
8786 )?
8787 }
8788
8789 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
8790 raw,
8791 decoder,
8792 (),
8793 )?,
8794
8795 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
8796 raw,
8797 decoder,
8798 (),
8799 )?,
8800
8801 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
8802 raw,
8803 decoder,
8804 (),
8805 )?,
8806
8807 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
8808 raw,
8809 decoder,
8810 (),
8811 )?,
8812
8813 7 => ::fidl_next::RawWireUnion::decode_as::<
8814 ___D,
8815 ::fidl_next::ClientEnd<
8816 ::fidl_next_fuchsia_io::Directory,
8817 ::fidl_next::fuchsia::WireChannel,
8818 >,
8819 >(raw, decoder, ())?,
8820
8821 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
8822 raw,
8823 decoder,
8824 (),
8825 )?,
8826
8827 9 => ::fidl_next::RawWireUnion::decode_as::<
8828 ___D,
8829 ::fidl_next::ClientEnd<
8830 crate::ConnectorRouter,
8831 ::fidl_next::fuchsia::WireChannel,
8832 >,
8833 >(raw, decoder, ())?,
8834
8835 10 => ::fidl_next::RawWireUnion::decode_as::<
8836 ___D,
8837 ::fidl_next::ClientEnd<
8838 crate::DictionaryRouter,
8839 ::fidl_next::fuchsia::WireChannel,
8840 >,
8841 >(raw, decoder, ())?,
8842
8843 11 => ::fidl_next::RawWireUnion::decode_as::<
8844 ___D,
8845 ::fidl_next::ClientEnd<
8846 crate::DirEntryRouter,
8847 ::fidl_next::fuchsia::WireChannel,
8848 >,
8849 >(raw, decoder, ())?,
8850
8851 12 => ::fidl_next::RawWireUnion::decode_as::<
8852 ___D,
8853 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
8854 >(raw, decoder, ())?,
8855
8856 13 => ::fidl_next::RawWireUnion::decode_as::<
8857 ___D,
8858 ::fidl_next::ClientEnd<
8859 crate::DirConnectorRouter,
8860 ::fidl_next::fuchsia::WireChannel,
8861 >,
8862 >(raw, decoder, ())?,
8863
8864 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
8865 }
8866
8867 Ok(())
8868 }
8869 }
8870
8871 impl<'de> ::core::fmt::Debug for Capability<'de> {
8872 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8873 match self.raw.ordinal() {
8874 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
8875 2 => unsafe {
8876 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
8877 },
8878 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
8879 4 => unsafe {
8880 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
8881 },
8882 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
8883 6 => unsafe {
8884 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
8885 },
8886 7 => unsafe {
8887 self.raw
8888 .get()
8889 .deref_unchecked::<::fidl_next::ClientEnd<
8890 ::fidl_next_fuchsia_io::Directory,
8891 ::fidl_next::fuchsia::WireChannel,
8892 >>()
8893 .fmt(f)
8894 },
8895 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
8896 9 => unsafe {
8897 self.raw
8898 .get()
8899 .deref_unchecked::<::fidl_next::ClientEnd<
8900 crate::ConnectorRouter,
8901 ::fidl_next::fuchsia::WireChannel,
8902 >>()
8903 .fmt(f)
8904 },
8905 10 => unsafe {
8906 self.raw
8907 .get()
8908 .deref_unchecked::<::fidl_next::ClientEnd<
8909 crate::DictionaryRouter,
8910 ::fidl_next::fuchsia::WireChannel,
8911 >>()
8912 .fmt(f)
8913 },
8914 11 => unsafe {
8915 self.raw
8916 .get()
8917 .deref_unchecked::<::fidl_next::ClientEnd<
8918 crate::DirEntryRouter,
8919 ::fidl_next::fuchsia::WireChannel,
8920 >>()
8921 .fmt(f)
8922 },
8923 12 => unsafe {
8924 self.raw.get().deref_unchecked::<
8925 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
8926 >().fmt(f)
8927 },
8928 13 => unsafe {
8929 self.raw
8930 .get()
8931 .deref_unchecked::<::fidl_next::ClientEnd<
8932 crate::DirConnectorRouter,
8933 ::fidl_next::fuchsia::WireChannel,
8934 >>()
8935 .fmt(f)
8936 },
8937 _ => unsafe { ::core::hint::unreachable_unchecked() },
8938 }
8939 }
8940 }
8941
8942 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
8943 type Natural = crate::natural::Capability;
8944 }
8945
8946 impl ::fidl_next::Unconstrained for Capability<'static> {}
8947
8948 pub type CapabilityId = ::fidl_next::WireU64;
8950
8951 pub type NewCapabilityId = ::fidl_next::WireU64;
8953
8954 #[derive(Clone, Debug)]
8956 #[repr(C)]
8957 pub struct CapabilityStoreDuplicateRequest {
8958 pub id: ::fidl_next::WireU64,
8959
8960 pub dest_id: ::fidl_next::WireU64,
8961 }
8962
8963 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateRequest>(), 16);
8964 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDuplicateRequest>(), 8);
8965
8966 static_assertions::const_assert_eq!(
8967 std::mem::offset_of!(CapabilityStoreDuplicateRequest, id),
8968 0
8969 );
8970
8971 static_assertions::const_assert_eq!(
8972 std::mem::offset_of!(CapabilityStoreDuplicateRequest, dest_id),
8973 8
8974 );
8975
8976 unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateRequest {
8977 type Decoded<'de> = CapabilityStoreDuplicateRequest;
8978
8979 #[inline]
8980 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8981 ::fidl_next::munge! {
8982 let Self {
8983
8984 id,
8985 dest_id,
8986
8987 } = &mut *out_;
8988 }
8989
8990 ::fidl_next::Wire::zero_padding(id);
8991
8992 ::fidl_next::Wire::zero_padding(dest_id);
8993 }
8994 }
8995
8996 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateRequest
8997 where
8998 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8999 {
9000 fn decode(
9001 slot_: ::fidl_next::Slot<'_, Self>,
9002 decoder_: &mut ___D,
9003 _: (),
9004 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9005 ::fidl_next::munge! {
9006 let Self {
9007
9008 mut id,
9009 mut dest_id,
9010
9011 } = slot_;
9012 }
9013
9014 let _field = id.as_mut();
9015
9016 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9017
9018 let _field = dest_id.as_mut();
9019
9020 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
9021
9022 Ok(())
9023 }
9024 }
9025
9026 impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateRequest {
9027 type Natural = crate::natural::CapabilityStoreDuplicateRequest;
9028 }
9029
9030 impl ::fidl_next::Unconstrained for CapabilityStoreDuplicateRequest {}
9031
9032 #[derive(Clone, Debug)]
9034 #[repr(C)]
9035 pub struct CapabilityStoreDuplicateResponse {
9036 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9037 }
9038
9039 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateResponse>(), 1);
9040 static_assertions::const_assert_eq!(
9041 std::mem::align_of::<CapabilityStoreDuplicateResponse>(),
9042 1
9043 );
9044
9045 unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateResponse {
9046 type Decoded<'de> = CapabilityStoreDuplicateResponse;
9047
9048 #[inline]
9049 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9050 ::fidl_next::munge! {
9051 let Self {
9052
9053 _empty,
9054
9055
9056 } = &mut *out_;
9057 }
9058 }
9059 }
9060
9061 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateResponse
9062 where
9063 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9064 {
9065 fn decode(
9066 slot_: ::fidl_next::Slot<'_, Self>,
9067 decoder_: &mut ___D,
9068 _: (),
9069 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9070 ::fidl_next::munge! {
9071 let Self {
9072
9073 mut _empty,
9074
9075
9076 } = slot_;
9077 }
9078
9079 if _empty.as_bytes() != &[0u8] {
9080 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9081 }
9082
9083 Ok(())
9084 }
9085 }
9086
9087 impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateResponse {
9088 type Natural = crate::natural::CapabilityStoreDuplicateResponse;
9089 }
9090
9091 impl ::fidl_next::Unconstrained for CapabilityStoreDuplicateResponse {}
9092
9093 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9095 #[repr(transparent)]
9096 pub struct CapabilityStoreError {
9097 pub(crate) value: ::fidl_next::WireU32,
9098 }
9099
9100 unsafe impl ::fidl_next::Wire for CapabilityStoreError {
9101 type Decoded<'de> = Self;
9102
9103 #[inline]
9104 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9105 }
9107 }
9108
9109 impl CapabilityStoreError {
9110 pub const ID_NOT_FOUND: CapabilityStoreError =
9111 CapabilityStoreError { value: ::fidl_next::WireU32(1) };
9112
9113 pub const ID_ALREADY_EXISTS: CapabilityStoreError =
9114 CapabilityStoreError { value: ::fidl_next::WireU32(2) };
9115
9116 pub const BAD_CAPABILITY: CapabilityStoreError =
9117 CapabilityStoreError { value: ::fidl_next::WireU32(3) };
9118
9119 pub const WRONG_TYPE: CapabilityStoreError =
9120 CapabilityStoreError { value: ::fidl_next::WireU32(4) };
9121
9122 pub const NOT_DUPLICATABLE: CapabilityStoreError =
9123 CapabilityStoreError { value: ::fidl_next::WireU32(5) };
9124
9125 pub const ITEM_NOT_FOUND: CapabilityStoreError =
9126 CapabilityStoreError { value: ::fidl_next::WireU32(6) };
9127
9128 pub const ITEM_ALREADY_EXISTS: CapabilityStoreError =
9129 CapabilityStoreError { value: ::fidl_next::WireU32(7) };
9130
9131 pub const INVALID_KEY: CapabilityStoreError =
9132 CapabilityStoreError { value: ::fidl_next::WireU32(8) };
9133
9134 pub const INVALID_ARGS: CapabilityStoreError =
9135 CapabilityStoreError { value: ::fidl_next::WireU32(9) };
9136 }
9137
9138 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreError
9139 where
9140 ___D: ?Sized,
9141 {
9142 fn decode(
9143 slot: ::fidl_next::Slot<'_, Self>,
9144 _: &mut ___D,
9145 _: (),
9146 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9147 Ok(())
9148 }
9149 }
9150
9151 impl ::core::convert::From<crate::natural::CapabilityStoreError> for CapabilityStoreError {
9152 fn from(natural: crate::natural::CapabilityStoreError) -> Self {
9153 match natural {
9154 crate::natural::CapabilityStoreError::IdNotFound => {
9155 CapabilityStoreError::ID_NOT_FOUND
9156 }
9157
9158 crate::natural::CapabilityStoreError::IdAlreadyExists => {
9159 CapabilityStoreError::ID_ALREADY_EXISTS
9160 }
9161
9162 crate::natural::CapabilityStoreError::BadCapability => {
9163 CapabilityStoreError::BAD_CAPABILITY
9164 }
9165
9166 crate::natural::CapabilityStoreError::WrongType => CapabilityStoreError::WRONG_TYPE,
9167
9168 crate::natural::CapabilityStoreError::NotDuplicatable => {
9169 CapabilityStoreError::NOT_DUPLICATABLE
9170 }
9171
9172 crate::natural::CapabilityStoreError::ItemNotFound => {
9173 CapabilityStoreError::ITEM_NOT_FOUND
9174 }
9175
9176 crate::natural::CapabilityStoreError::ItemAlreadyExists => {
9177 CapabilityStoreError::ITEM_ALREADY_EXISTS
9178 }
9179
9180 crate::natural::CapabilityStoreError::InvalidKey => {
9181 CapabilityStoreError::INVALID_KEY
9182 }
9183
9184 crate::natural::CapabilityStoreError::InvalidArgs => {
9185 CapabilityStoreError::INVALID_ARGS
9186 }
9187
9188 crate::natural::CapabilityStoreError::UnknownOrdinal_(value) => {
9189 CapabilityStoreError { value: ::fidl_next::WireU32::from(value) }
9190 }
9191 }
9192 }
9193 }
9194
9195 impl ::fidl_next::IntoNatural for CapabilityStoreError {
9196 type Natural = crate::natural::CapabilityStoreError;
9197 }
9198
9199 impl ::fidl_next::Unconstrained for CapabilityStoreError {}
9200
9201 #[derive(Clone, Debug)]
9203 #[repr(C)]
9204 pub struct CapabilityStoreDropRequest {
9205 pub id: ::fidl_next::WireU64,
9206 }
9207
9208 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropRequest>(), 8);
9209 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropRequest>(), 8);
9210
9211 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreDropRequest, id), 0);
9212
9213 unsafe impl ::fidl_next::Wire for CapabilityStoreDropRequest {
9214 type Decoded<'de> = CapabilityStoreDropRequest;
9215
9216 #[inline]
9217 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9218 ::fidl_next::munge! {
9219 let Self {
9220
9221 id,
9222
9223 } = &mut *out_;
9224 }
9225
9226 ::fidl_next::Wire::zero_padding(id);
9227 }
9228 }
9229
9230 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropRequest
9231 where
9232 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9233 {
9234 fn decode(
9235 slot_: ::fidl_next::Slot<'_, Self>,
9236 decoder_: &mut ___D,
9237 _: (),
9238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9239 ::fidl_next::munge! {
9240 let Self {
9241
9242 mut id,
9243
9244 } = slot_;
9245 }
9246
9247 let _field = id.as_mut();
9248
9249 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9250
9251 Ok(())
9252 }
9253 }
9254
9255 impl ::fidl_next::IntoNatural for CapabilityStoreDropRequest {
9256 type Natural = crate::natural::CapabilityStoreDropRequest;
9257 }
9258
9259 impl ::fidl_next::Unconstrained for CapabilityStoreDropRequest {}
9260
9261 #[derive(Clone, Debug)]
9263 #[repr(C)]
9264 pub struct CapabilityStoreDropResponse {
9265 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9266 }
9267
9268 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropResponse>(), 1);
9269 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropResponse>(), 1);
9270
9271 unsafe impl ::fidl_next::Wire for CapabilityStoreDropResponse {
9272 type Decoded<'de> = CapabilityStoreDropResponse;
9273
9274 #[inline]
9275 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9276 ::fidl_next::munge! {
9277 let Self {
9278
9279 _empty,
9280
9281
9282 } = &mut *out_;
9283 }
9284 }
9285 }
9286
9287 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropResponse
9288 where
9289 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9290 {
9291 fn decode(
9292 slot_: ::fidl_next::Slot<'_, Self>,
9293 decoder_: &mut ___D,
9294 _: (),
9295 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9296 ::fidl_next::munge! {
9297 let Self {
9298
9299 mut _empty,
9300
9301
9302 } = slot_;
9303 }
9304
9305 if _empty.as_bytes() != &[0u8] {
9306 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9307 }
9308
9309 Ok(())
9310 }
9311 }
9312
9313 impl ::fidl_next::IntoNatural for CapabilityStoreDropResponse {
9314 type Natural = crate::natural::CapabilityStoreDropResponse;
9315 }
9316
9317 impl ::fidl_next::Unconstrained for CapabilityStoreDropResponse {}
9318
9319 #[derive(Clone, Debug)]
9321 #[repr(C)]
9322 pub struct CapabilityStoreExportRequest {
9323 pub id: ::fidl_next::WireU64,
9324 }
9325
9326 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreExportRequest>(), 8);
9327 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreExportRequest>(), 8);
9328
9329 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreExportRequest, id), 0);
9330
9331 unsafe impl ::fidl_next::Wire for CapabilityStoreExportRequest {
9332 type Decoded<'de> = CapabilityStoreExportRequest;
9333
9334 #[inline]
9335 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9336 ::fidl_next::munge! {
9337 let Self {
9338
9339 id,
9340
9341 } = &mut *out_;
9342 }
9343
9344 ::fidl_next::Wire::zero_padding(id);
9345 }
9346 }
9347
9348 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportRequest
9349 where
9350 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9351 {
9352 fn decode(
9353 slot_: ::fidl_next::Slot<'_, Self>,
9354 decoder_: &mut ___D,
9355 _: (),
9356 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9357 ::fidl_next::munge! {
9358 let Self {
9359
9360 mut id,
9361
9362 } = slot_;
9363 }
9364
9365 let _field = id.as_mut();
9366
9367 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9368
9369 Ok(())
9370 }
9371 }
9372
9373 impl ::fidl_next::IntoNatural for CapabilityStoreExportRequest {
9374 type Natural = crate::natural::CapabilityStoreExportRequest;
9375 }
9376
9377 impl ::fidl_next::Unconstrained for CapabilityStoreExportRequest {}
9378
9379 #[derive(Clone, Debug)]
9381 #[repr(C)]
9382 pub struct CapabilityStoreImportResponse {
9383 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9384 }
9385
9386 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreImportResponse>(), 1);
9387 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreImportResponse>(), 1);
9388
9389 unsafe impl ::fidl_next::Wire for CapabilityStoreImportResponse {
9390 type Decoded<'de> = CapabilityStoreImportResponse;
9391
9392 #[inline]
9393 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9394 ::fidl_next::munge! {
9395 let Self {
9396
9397 _empty,
9398
9399
9400 } = &mut *out_;
9401 }
9402 }
9403 }
9404
9405 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportResponse
9406 where
9407 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9408 {
9409 fn decode(
9410 slot_: ::fidl_next::Slot<'_, Self>,
9411 decoder_: &mut ___D,
9412 _: (),
9413 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9414 ::fidl_next::munge! {
9415 let Self {
9416
9417 mut _empty,
9418
9419
9420 } = slot_;
9421 }
9422
9423 if _empty.as_bytes() != &[0u8] {
9424 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9425 }
9426
9427 Ok(())
9428 }
9429 }
9430
9431 impl ::fidl_next::IntoNatural for CapabilityStoreImportResponse {
9432 type Natural = crate::natural::CapabilityStoreImportResponse;
9433 }
9434
9435 impl ::fidl_next::Unconstrained for CapabilityStoreImportResponse {}
9436
9437 #[derive(Debug)]
9439 #[repr(C)]
9440 pub struct CapabilityStoreConnectorCreateRequest {
9441 pub id: ::fidl_next::WireU64,
9442
9443 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
9444 }
9445
9446 static_assertions::const_assert_eq!(
9447 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
9448 16
9449 );
9450 static_assertions::const_assert_eq!(
9451 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
9452 8
9453 );
9454
9455 static_assertions::const_assert_eq!(
9456 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
9457 0
9458 );
9459
9460 static_assertions::const_assert_eq!(
9461 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
9462 8
9463 );
9464
9465 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
9466 type Decoded<'de> = CapabilityStoreConnectorCreateRequest;
9467
9468 #[inline]
9469 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9470 ::fidl_next::munge! {
9471 let Self {
9472
9473 id,
9474 receiver,
9475
9476 } = &mut *out_;
9477 }
9478
9479 ::fidl_next::Wire::zero_padding(id);
9480
9481 ::fidl_next::Wire::zero_padding(receiver);
9482
9483 unsafe {
9484 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
9485 }
9486 }
9487 }
9488
9489 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
9490 where
9491 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9492 ___D: ::fidl_next::fuchsia::HandleDecoder,
9493 {
9494 fn decode(
9495 slot_: ::fidl_next::Slot<'_, Self>,
9496 decoder_: &mut ___D,
9497 _: (),
9498 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9499 if slot_.as_bytes()[12..16] != [0u8; 4] {
9500 return Err(::fidl_next::DecodeError::InvalidPadding);
9501 }
9502
9503 ::fidl_next::munge! {
9504 let Self {
9505
9506 mut id,
9507 mut receiver,
9508
9509 } = slot_;
9510 }
9511
9512 let _field = id.as_mut();
9513
9514 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9515
9516 let _field = receiver.as_mut();
9517
9518 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
9519
9520 Ok(())
9521 }
9522 }
9523
9524 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
9525 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
9526 }
9527
9528 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateRequest {}
9529
9530 #[derive(Clone, Debug)]
9532 #[repr(C)]
9533 pub struct CapabilityStoreConnectorCreateResponse {
9534 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9535 }
9536
9537 static_assertions::const_assert_eq!(
9538 std::mem::size_of::<CapabilityStoreConnectorCreateResponse>(),
9539 1
9540 );
9541 static_assertions::const_assert_eq!(
9542 std::mem::align_of::<CapabilityStoreConnectorCreateResponse>(),
9543 1
9544 );
9545
9546 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateResponse {
9547 type Decoded<'de> = CapabilityStoreConnectorCreateResponse;
9548
9549 #[inline]
9550 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9551 ::fidl_next::munge! {
9552 let Self {
9553
9554 _empty,
9555
9556
9557 } = &mut *out_;
9558 }
9559 }
9560 }
9561
9562 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateResponse
9563 where
9564 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9565 {
9566 fn decode(
9567 slot_: ::fidl_next::Slot<'_, Self>,
9568 decoder_: &mut ___D,
9569 _: (),
9570 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9571 ::fidl_next::munge! {
9572 let Self {
9573
9574 mut _empty,
9575
9576
9577 } = slot_;
9578 }
9579
9580 if _empty.as_bytes() != &[0u8] {
9581 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9582 }
9583
9584 Ok(())
9585 }
9586 }
9587
9588 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateResponse {
9589 type Natural = crate::natural::CapabilityStoreConnectorCreateResponse;
9590 }
9591
9592 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateResponse {}
9593
9594 #[derive(Debug)]
9596 #[repr(C)]
9597 pub struct CapabilityStoreConnectorOpenRequest {
9598 pub id: ::fidl_next::WireU64,
9599
9600 pub server_end: ::fidl_next::fuchsia::WireChannel,
9601 }
9602
9603 static_assertions::const_assert_eq!(
9604 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
9605 16
9606 );
9607 static_assertions::const_assert_eq!(
9608 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
9609 8
9610 );
9611
9612 static_assertions::const_assert_eq!(
9613 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
9614 0
9615 );
9616
9617 static_assertions::const_assert_eq!(
9618 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
9619 8
9620 );
9621
9622 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
9623 type Decoded<'de> = CapabilityStoreConnectorOpenRequest;
9624
9625 #[inline]
9626 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9627 ::fidl_next::munge! {
9628 let Self {
9629
9630 id,
9631 server_end,
9632
9633 } = &mut *out_;
9634 }
9635
9636 ::fidl_next::Wire::zero_padding(id);
9637
9638 ::fidl_next::Wire::zero_padding(server_end);
9639
9640 unsafe {
9641 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
9642 }
9643 }
9644 }
9645
9646 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
9647 where
9648 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9649 ___D: ::fidl_next::fuchsia::HandleDecoder,
9650 {
9651 fn decode(
9652 slot_: ::fidl_next::Slot<'_, Self>,
9653 decoder_: &mut ___D,
9654 _: (),
9655 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9656 if slot_.as_bytes()[12..16] != [0u8; 4] {
9657 return Err(::fidl_next::DecodeError::InvalidPadding);
9658 }
9659
9660 ::fidl_next::munge! {
9661 let Self {
9662
9663 mut id,
9664 mut server_end,
9665
9666 } = slot_;
9667 }
9668
9669 let _field = id.as_mut();
9670
9671 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9672
9673 let _field = server_end.as_mut();
9674
9675 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
9676
9677 Ok(())
9678 }
9679 }
9680
9681 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
9682 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
9683 }
9684
9685 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenRequest {}
9686
9687 #[derive(Clone, Debug)]
9689 #[repr(C)]
9690 pub struct CapabilityStoreConnectorOpenResponse {
9691 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9692 }
9693
9694 static_assertions::const_assert_eq!(
9695 std::mem::size_of::<CapabilityStoreConnectorOpenResponse>(),
9696 1
9697 );
9698 static_assertions::const_assert_eq!(
9699 std::mem::align_of::<CapabilityStoreConnectorOpenResponse>(),
9700 1
9701 );
9702
9703 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenResponse {
9704 type Decoded<'de> = CapabilityStoreConnectorOpenResponse;
9705
9706 #[inline]
9707 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9708 ::fidl_next::munge! {
9709 let Self {
9710
9711 _empty,
9712
9713
9714 } = &mut *out_;
9715 }
9716 }
9717 }
9718
9719 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenResponse
9720 where
9721 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9722 {
9723 fn decode(
9724 slot_: ::fidl_next::Slot<'_, Self>,
9725 decoder_: &mut ___D,
9726 _: (),
9727 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9728 ::fidl_next::munge! {
9729 let Self {
9730
9731 mut _empty,
9732
9733
9734 } = slot_;
9735 }
9736
9737 if _empty.as_bytes() != &[0u8] {
9738 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9739 }
9740
9741 Ok(())
9742 }
9743 }
9744
9745 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenResponse {
9746 type Natural = crate::natural::CapabilityStoreConnectorOpenResponse;
9747 }
9748
9749 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenResponse {}
9750
9751 #[derive(Clone, Debug)]
9753 #[repr(C)]
9754 pub struct CapabilityStoreDirConnectorCreateResponse {
9755 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9756 }
9757
9758 static_assertions::const_assert_eq!(
9759 std::mem::size_of::<CapabilityStoreDirConnectorCreateResponse>(),
9760 1
9761 );
9762 static_assertions::const_assert_eq!(
9763 std::mem::align_of::<CapabilityStoreDirConnectorCreateResponse>(),
9764 1
9765 );
9766
9767 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateResponse {
9768 type Decoded<'de> = CapabilityStoreDirConnectorCreateResponse;
9769
9770 #[inline]
9771 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9772 ::fidl_next::munge! {
9773 let Self {
9774
9775 _empty,
9776
9777
9778 } = &mut *out_;
9779 }
9780 }
9781 }
9782
9783 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateResponse
9784 where
9785 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9786 {
9787 fn decode(
9788 slot_: ::fidl_next::Slot<'_, Self>,
9789 decoder_: &mut ___D,
9790 _: (),
9791 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9792 ::fidl_next::munge! {
9793 let Self {
9794
9795 mut _empty,
9796
9797
9798 } = slot_;
9799 }
9800
9801 if _empty.as_bytes() != &[0u8] {
9802 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9803 }
9804
9805 Ok(())
9806 }
9807 }
9808
9809 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateResponse {
9810 type Natural = crate::natural::CapabilityStoreDirConnectorCreateResponse;
9811 }
9812
9813 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateResponse {}
9814
9815 #[derive(Clone, Debug)]
9817 #[repr(C)]
9818 pub struct CapabilityStoreDirConnectorOpenResponse {
9819 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9820 }
9821
9822 static_assertions::const_assert_eq!(
9823 std::mem::size_of::<CapabilityStoreDirConnectorOpenResponse>(),
9824 1
9825 );
9826 static_assertions::const_assert_eq!(
9827 std::mem::align_of::<CapabilityStoreDirConnectorOpenResponse>(),
9828 1
9829 );
9830
9831 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenResponse {
9832 type Decoded<'de> = CapabilityStoreDirConnectorOpenResponse;
9833
9834 #[inline]
9835 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9836 ::fidl_next::munge! {
9837 let Self {
9838
9839 _empty,
9840
9841
9842 } = &mut *out_;
9843 }
9844 }
9845 }
9846
9847 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenResponse
9848 where
9849 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9850 {
9851 fn decode(
9852 slot_: ::fidl_next::Slot<'_, Self>,
9853 decoder_: &mut ___D,
9854 _: (),
9855 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9856 ::fidl_next::munge! {
9857 let Self {
9858
9859 mut _empty,
9860
9861
9862 } = slot_;
9863 }
9864
9865 if _empty.as_bytes() != &[0u8] {
9866 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9867 }
9868
9869 Ok(())
9870 }
9871 }
9872
9873 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenResponse {
9874 type Natural = crate::natural::CapabilityStoreDirConnectorOpenResponse;
9875 }
9876
9877 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenResponse {}
9878
9879 #[derive(Clone, Debug)]
9881 #[repr(C)]
9882 pub struct CapabilityStoreDictionaryCreateRequest {
9883 pub id: ::fidl_next::WireU64,
9884 }
9885
9886 static_assertions::const_assert_eq!(
9887 std::mem::size_of::<CapabilityStoreDictionaryCreateRequest>(),
9888 8
9889 );
9890 static_assertions::const_assert_eq!(
9891 std::mem::align_of::<CapabilityStoreDictionaryCreateRequest>(),
9892 8
9893 );
9894
9895 static_assertions::const_assert_eq!(
9896 std::mem::offset_of!(CapabilityStoreDictionaryCreateRequest, id),
9897 0
9898 );
9899
9900 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateRequest {
9901 type Decoded<'de> = CapabilityStoreDictionaryCreateRequest;
9902
9903 #[inline]
9904 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9905 ::fidl_next::munge! {
9906 let Self {
9907
9908 id,
9909
9910 } = &mut *out_;
9911 }
9912
9913 ::fidl_next::Wire::zero_padding(id);
9914 }
9915 }
9916
9917 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateRequest
9918 where
9919 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9920 {
9921 fn decode(
9922 slot_: ::fidl_next::Slot<'_, Self>,
9923 decoder_: &mut ___D,
9924 _: (),
9925 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9926 ::fidl_next::munge! {
9927 let Self {
9928
9929 mut id,
9930
9931 } = slot_;
9932 }
9933
9934 let _field = id.as_mut();
9935
9936 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9937
9938 Ok(())
9939 }
9940 }
9941
9942 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateRequest {
9943 type Natural = crate::natural::CapabilityStoreDictionaryCreateRequest;
9944 }
9945
9946 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCreateRequest {}
9947
9948 #[derive(Clone, Debug)]
9950 #[repr(C)]
9951 pub struct CapabilityStoreDictionaryCreateResponse {
9952 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9953 }
9954
9955 static_assertions::const_assert_eq!(
9956 std::mem::size_of::<CapabilityStoreDictionaryCreateResponse>(),
9957 1
9958 );
9959 static_assertions::const_assert_eq!(
9960 std::mem::align_of::<CapabilityStoreDictionaryCreateResponse>(),
9961 1
9962 );
9963
9964 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateResponse {
9965 type Decoded<'de> = CapabilityStoreDictionaryCreateResponse;
9966
9967 #[inline]
9968 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9969 ::fidl_next::munge! {
9970 let Self {
9971
9972 _empty,
9973
9974
9975 } = &mut *out_;
9976 }
9977 }
9978 }
9979
9980 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateResponse
9981 where
9982 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9983 {
9984 fn decode(
9985 slot_: ::fidl_next::Slot<'_, Self>,
9986 decoder_: &mut ___D,
9987 _: (),
9988 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9989 ::fidl_next::munge! {
9990 let Self {
9991
9992 mut _empty,
9993
9994
9995 } = slot_;
9996 }
9997
9998 if _empty.as_bytes() != &[0u8] {
9999 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10000 }
10001
10002 Ok(())
10003 }
10004 }
10005
10006 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateResponse {
10007 type Natural = crate::natural::CapabilityStoreDictionaryCreateResponse;
10008 }
10009
10010 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCreateResponse {}
10011
10012 #[derive(Debug)]
10014 #[repr(C)]
10015 pub struct CapabilityStoreDictionaryLegacyImportRequest {
10016 pub id: ::fidl_next::WireU64,
10017
10018 pub client_end: ::fidl_next::fuchsia::WireChannel,
10019 }
10020
10021 static_assertions::const_assert_eq!(
10022 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
10023 16
10024 );
10025 static_assertions::const_assert_eq!(
10026 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
10027 8
10028 );
10029
10030 static_assertions::const_assert_eq!(
10031 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
10032 0
10033 );
10034
10035 static_assertions::const_assert_eq!(
10036 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
10037 8
10038 );
10039
10040 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
10041 type Decoded<'de> = CapabilityStoreDictionaryLegacyImportRequest;
10042
10043 #[inline]
10044 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10045 ::fidl_next::munge! {
10046 let Self {
10047
10048 id,
10049 client_end,
10050
10051 } = &mut *out_;
10052 }
10053
10054 ::fidl_next::Wire::zero_padding(id);
10055
10056 ::fidl_next::Wire::zero_padding(client_end);
10057
10058 unsafe {
10059 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10060 }
10061 }
10062 }
10063
10064 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
10065 where
10066 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10067 ___D: ::fidl_next::fuchsia::HandleDecoder,
10068 {
10069 fn decode(
10070 slot_: ::fidl_next::Slot<'_, Self>,
10071 decoder_: &mut ___D,
10072 _: (),
10073 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10074 if slot_.as_bytes()[12..16] != [0u8; 4] {
10075 return Err(::fidl_next::DecodeError::InvalidPadding);
10076 }
10077
10078 ::fidl_next::munge! {
10079 let Self {
10080
10081 mut id,
10082 mut client_end,
10083
10084 } = slot_;
10085 }
10086
10087 let _field = id.as_mut();
10088
10089 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10090
10091 let _field = client_end.as_mut();
10092
10093 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
10094
10095 Ok(())
10096 }
10097 }
10098
10099 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
10100 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
10101 }
10102
10103 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportRequest {}
10104
10105 #[derive(Clone, Debug)]
10107 #[repr(C)]
10108 pub struct CapabilityStoreDictionaryLegacyImportResponse {
10109 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10110 }
10111
10112 static_assertions::const_assert_eq!(
10113 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
10114 1
10115 );
10116 static_assertions::const_assert_eq!(
10117 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
10118 1
10119 );
10120
10121 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportResponse {
10122 type Decoded<'de> = CapabilityStoreDictionaryLegacyImportResponse;
10123
10124 #[inline]
10125 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10126 ::fidl_next::munge! {
10127 let Self {
10128
10129 _empty,
10130
10131
10132 } = &mut *out_;
10133 }
10134 }
10135 }
10136
10137 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportResponse
10138 where
10139 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10140 {
10141 fn decode(
10142 slot_: ::fidl_next::Slot<'_, Self>,
10143 decoder_: &mut ___D,
10144 _: (),
10145 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10146 ::fidl_next::munge! {
10147 let Self {
10148
10149 mut _empty,
10150
10151
10152 } = slot_;
10153 }
10154
10155 if _empty.as_bytes() != &[0u8] {
10156 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10157 }
10158
10159 Ok(())
10160 }
10161 }
10162
10163 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportResponse {
10164 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
10165 }
10166
10167 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportResponse {}
10168
10169 #[derive(Debug)]
10171 #[repr(C)]
10172 pub struct CapabilityStoreDictionaryLegacyExportRequest {
10173 pub id: ::fidl_next::WireU64,
10174
10175 pub server_end: ::fidl_next::fuchsia::WireChannel,
10176 }
10177
10178 static_assertions::const_assert_eq!(
10179 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
10180 16
10181 );
10182 static_assertions::const_assert_eq!(
10183 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
10184 8
10185 );
10186
10187 static_assertions::const_assert_eq!(
10188 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
10189 0
10190 );
10191
10192 static_assertions::const_assert_eq!(
10193 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
10194 8
10195 );
10196
10197 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
10198 type Decoded<'de> = CapabilityStoreDictionaryLegacyExportRequest;
10199
10200 #[inline]
10201 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10202 ::fidl_next::munge! {
10203 let Self {
10204
10205 id,
10206 server_end,
10207
10208 } = &mut *out_;
10209 }
10210
10211 ::fidl_next::Wire::zero_padding(id);
10212
10213 ::fidl_next::Wire::zero_padding(server_end);
10214
10215 unsafe {
10216 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10217 }
10218 }
10219 }
10220
10221 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
10222 where
10223 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10224 ___D: ::fidl_next::fuchsia::HandleDecoder,
10225 {
10226 fn decode(
10227 slot_: ::fidl_next::Slot<'_, Self>,
10228 decoder_: &mut ___D,
10229 _: (),
10230 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10231 if slot_.as_bytes()[12..16] != [0u8; 4] {
10232 return Err(::fidl_next::DecodeError::InvalidPadding);
10233 }
10234
10235 ::fidl_next::munge! {
10236 let Self {
10237
10238 mut id,
10239 mut server_end,
10240
10241 } = slot_;
10242 }
10243
10244 let _field = id.as_mut();
10245
10246 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10247
10248 let _field = server_end.as_mut();
10249
10250 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
10251
10252 Ok(())
10253 }
10254 }
10255
10256 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
10257 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
10258 }
10259
10260 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportRequest {}
10261
10262 #[derive(Clone, Debug)]
10264 #[repr(C)]
10265 pub struct CapabilityStoreDictionaryLegacyExportResponse {
10266 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10267 }
10268
10269 static_assertions::const_assert_eq!(
10270 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
10271 1
10272 );
10273 static_assertions::const_assert_eq!(
10274 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
10275 1
10276 );
10277
10278 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportResponse {
10279 type Decoded<'de> = CapabilityStoreDictionaryLegacyExportResponse;
10280
10281 #[inline]
10282 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10283 ::fidl_next::munge! {
10284 let Self {
10285
10286 _empty,
10287
10288
10289 } = &mut *out_;
10290 }
10291 }
10292 }
10293
10294 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportResponse
10295 where
10296 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10297 {
10298 fn decode(
10299 slot_: ::fidl_next::Slot<'_, Self>,
10300 decoder_: &mut ___D,
10301 _: (),
10302 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10303 ::fidl_next::munge! {
10304 let Self {
10305
10306 mut _empty,
10307
10308
10309 } = slot_;
10310 }
10311
10312 if _empty.as_bytes() != &[0u8] {
10313 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10314 }
10315
10316 Ok(())
10317 }
10318 }
10319
10320 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportResponse {
10321 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
10322 }
10323
10324 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportResponse {}
10325
10326 pub type DictionaryKey<'de> = ::fidl_next::WireString<'de>;
10328
10329 #[derive(Debug)]
10331 #[repr(C)]
10332 pub struct DictionaryItem<'de> {
10333 pub key: ::fidl_next::WireString<'de>,
10334
10335 pub value: ::fidl_next::WireU64,
10336 }
10337
10338 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryItem<'_>>(), 24);
10339 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryItem<'_>>(), 8);
10340
10341 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, key), 0);
10342
10343 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, value), 16);
10344
10345 unsafe impl ::fidl_next::Wire for DictionaryItem<'static> {
10346 type Decoded<'de> = DictionaryItem<'de>;
10347
10348 #[inline]
10349 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10350 ::fidl_next::munge! {
10351 let Self {
10352
10353 key,
10354 value,
10355
10356 } = &mut *out_;
10357 }
10358
10359 ::fidl_next::Wire::zero_padding(key);
10360
10361 ::fidl_next::Wire::zero_padding(value);
10362 }
10363 }
10364
10365 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryItem<'static>
10366 where
10367 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10368 ___D: ::fidl_next::Decoder,
10369 {
10370 fn decode(
10371 slot_: ::fidl_next::Slot<'_, Self>,
10372 decoder_: &mut ___D,
10373 _: (),
10374 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10375 ::fidl_next::munge! {
10376 let Self {
10377
10378 mut key,
10379 mut value,
10380
10381 } = slot_;
10382 }
10383
10384 let _field = key.as_mut();
10385 ::fidl_next::Constrained::validate(_field, 255)?;
10386 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10387
10388 let key = unsafe { key.deref_unchecked() };
10389
10390 if key.len() > 255 {
10391 return Err(::fidl_next::DecodeError::VectorTooLong {
10392 size: key.len() as u64,
10393 limit: 255,
10394 });
10395 }
10396
10397 let _field = value.as_mut();
10398
10399 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10400
10401 Ok(())
10402 }
10403 }
10404
10405 impl<'de> ::fidl_next::IntoNatural for DictionaryItem<'de> {
10406 type Natural = crate::natural::DictionaryItem;
10407 }
10408
10409 impl ::fidl_next::Unconstrained for DictionaryItem<'static> {}
10410
10411 #[derive(Debug)]
10413 #[repr(C)]
10414 pub struct CapabilityStoreDictionaryInsertRequest<'de> {
10415 pub id: ::fidl_next::WireU64,
10416
10417 pub item: crate::wire::DictionaryItem<'de>,
10418 }
10419
10420 static_assertions::const_assert_eq!(
10421 std::mem::size_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
10422 32
10423 );
10424 static_assertions::const_assert_eq!(
10425 std::mem::align_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
10426 8
10427 );
10428
10429 static_assertions::const_assert_eq!(
10430 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, id),
10431 0
10432 );
10433
10434 static_assertions::const_assert_eq!(
10435 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, item),
10436 8
10437 );
10438
10439 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertRequest<'static> {
10440 type Decoded<'de> = CapabilityStoreDictionaryInsertRequest<'de>;
10441
10442 #[inline]
10443 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10444 ::fidl_next::munge! {
10445 let Self {
10446
10447 id,
10448 item,
10449
10450 } = &mut *out_;
10451 }
10452
10453 ::fidl_next::Wire::zero_padding(id);
10454
10455 ::fidl_next::Wire::zero_padding(item);
10456 }
10457 }
10458
10459 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertRequest<'static>
10460 where
10461 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10462 ___D: ::fidl_next::Decoder,
10463 {
10464 fn decode(
10465 slot_: ::fidl_next::Slot<'_, Self>,
10466 decoder_: &mut ___D,
10467 _: (),
10468 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10469 ::fidl_next::munge! {
10470 let Self {
10471
10472 mut id,
10473 mut item,
10474
10475 } = slot_;
10476 }
10477
10478 let _field = id.as_mut();
10479
10480 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10481
10482 let _field = item.as_mut();
10483
10484 ::fidl_next::Decode::decode(item.as_mut(), decoder_, ())?;
10485
10486 Ok(())
10487 }
10488 }
10489
10490 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertRequest<'de> {
10491 type Natural = crate::natural::CapabilityStoreDictionaryInsertRequest;
10492 }
10493
10494 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryInsertRequest<'static> {}
10495
10496 #[derive(Clone, Debug)]
10498 #[repr(C)]
10499 pub struct CapabilityStoreDictionaryInsertResponse {
10500 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10501 }
10502
10503 static_assertions::const_assert_eq!(
10504 std::mem::size_of::<CapabilityStoreDictionaryInsertResponse>(),
10505 1
10506 );
10507 static_assertions::const_assert_eq!(
10508 std::mem::align_of::<CapabilityStoreDictionaryInsertResponse>(),
10509 1
10510 );
10511
10512 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertResponse {
10513 type Decoded<'de> = CapabilityStoreDictionaryInsertResponse;
10514
10515 #[inline]
10516 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10517 ::fidl_next::munge! {
10518 let Self {
10519
10520 _empty,
10521
10522
10523 } = &mut *out_;
10524 }
10525 }
10526 }
10527
10528 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertResponse
10529 where
10530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10531 {
10532 fn decode(
10533 slot_: ::fidl_next::Slot<'_, Self>,
10534 decoder_: &mut ___D,
10535 _: (),
10536 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10537 ::fidl_next::munge! {
10538 let Self {
10539
10540 mut _empty,
10541
10542
10543 } = slot_;
10544 }
10545
10546 if _empty.as_bytes() != &[0u8] {
10547 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10548 }
10549
10550 Ok(())
10551 }
10552 }
10553
10554 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertResponse {
10555 type Natural = crate::natural::CapabilityStoreDictionaryInsertResponse;
10556 }
10557
10558 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryInsertResponse {}
10559
10560 #[derive(Debug)]
10562 #[repr(C)]
10563 pub struct CapabilityStoreDictionaryGetRequest<'de> {
10564 pub id: ::fidl_next::WireU64,
10565
10566 pub key: ::fidl_next::WireString<'de>,
10567
10568 pub dest_id: ::fidl_next::WireU64,
10569 }
10570
10571 static_assertions::const_assert_eq!(
10572 std::mem::size_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
10573 32
10574 );
10575 static_assertions::const_assert_eq!(
10576 std::mem::align_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
10577 8
10578 );
10579
10580 static_assertions::const_assert_eq!(
10581 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, id),
10582 0
10583 );
10584
10585 static_assertions::const_assert_eq!(
10586 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, key),
10587 8
10588 );
10589
10590 static_assertions::const_assert_eq!(
10591 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, dest_id),
10592 24
10593 );
10594
10595 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetRequest<'static> {
10596 type Decoded<'de> = CapabilityStoreDictionaryGetRequest<'de>;
10597
10598 #[inline]
10599 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10600 ::fidl_next::munge! {
10601 let Self {
10602
10603 id,
10604 key,
10605 dest_id,
10606
10607 } = &mut *out_;
10608 }
10609
10610 ::fidl_next::Wire::zero_padding(id);
10611
10612 ::fidl_next::Wire::zero_padding(key);
10613
10614 ::fidl_next::Wire::zero_padding(dest_id);
10615 }
10616 }
10617
10618 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetRequest<'static>
10619 where
10620 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10621 ___D: ::fidl_next::Decoder,
10622 {
10623 fn decode(
10624 slot_: ::fidl_next::Slot<'_, Self>,
10625 decoder_: &mut ___D,
10626 _: (),
10627 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10628 ::fidl_next::munge! {
10629 let Self {
10630
10631 mut id,
10632 mut key,
10633 mut dest_id,
10634
10635 } = slot_;
10636 }
10637
10638 let _field = id.as_mut();
10639
10640 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10641
10642 let _field = key.as_mut();
10643 ::fidl_next::Constrained::validate(_field, 255)?;
10644 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10645
10646 let key = unsafe { key.deref_unchecked() };
10647
10648 if key.len() > 255 {
10649 return Err(::fidl_next::DecodeError::VectorTooLong {
10650 size: key.len() as u64,
10651 limit: 255,
10652 });
10653 }
10654
10655 let _field = dest_id.as_mut();
10656
10657 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
10658
10659 Ok(())
10660 }
10661 }
10662
10663 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetRequest<'de> {
10664 type Natural = crate::natural::CapabilityStoreDictionaryGetRequest;
10665 }
10666
10667 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryGetRequest<'static> {}
10668
10669 #[derive(Clone, Debug)]
10671 #[repr(C)]
10672 pub struct CapabilityStoreDictionaryGetResponse {
10673 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10674 }
10675
10676 static_assertions::const_assert_eq!(
10677 std::mem::size_of::<CapabilityStoreDictionaryGetResponse>(),
10678 1
10679 );
10680 static_assertions::const_assert_eq!(
10681 std::mem::align_of::<CapabilityStoreDictionaryGetResponse>(),
10682 1
10683 );
10684
10685 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetResponse {
10686 type Decoded<'de> = CapabilityStoreDictionaryGetResponse;
10687
10688 #[inline]
10689 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10690 ::fidl_next::munge! {
10691 let Self {
10692
10693 _empty,
10694
10695
10696 } = &mut *out_;
10697 }
10698 }
10699 }
10700
10701 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetResponse
10702 where
10703 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10704 {
10705 fn decode(
10706 slot_: ::fidl_next::Slot<'_, Self>,
10707 decoder_: &mut ___D,
10708 _: (),
10709 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10710 ::fidl_next::munge! {
10711 let Self {
10712
10713 mut _empty,
10714
10715
10716 } = slot_;
10717 }
10718
10719 if _empty.as_bytes() != &[0u8] {
10720 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10721 }
10722
10723 Ok(())
10724 }
10725 }
10726
10727 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetResponse {
10728 type Natural = crate::natural::CapabilityStoreDictionaryGetResponse;
10729 }
10730
10731 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryGetResponse {}
10732
10733 #[derive(Clone, Debug)]
10735 #[repr(C)]
10736 pub struct WrappedCapabilityId {
10737 pub id: ::fidl_next::WireU64,
10738 }
10739
10740 static_assertions::const_assert_eq!(std::mem::size_of::<WrappedCapabilityId>(), 8);
10741 static_assertions::const_assert_eq!(std::mem::align_of::<WrappedCapabilityId>(), 8);
10742
10743 static_assertions::const_assert_eq!(std::mem::offset_of!(WrappedCapabilityId, id), 0);
10744
10745 unsafe impl ::fidl_next::Wire for WrappedCapabilityId {
10746 type Decoded<'de> = WrappedCapabilityId;
10747
10748 #[inline]
10749 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10750 ::fidl_next::munge! {
10751 let Self {
10752
10753 id,
10754
10755 } = &mut *out_;
10756 }
10757
10758 ::fidl_next::Wire::zero_padding(id);
10759 }
10760 }
10761
10762 unsafe impl<___D> ::fidl_next::Decode<___D> for WrappedCapabilityId
10763 where
10764 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10765 {
10766 fn decode(
10767 slot_: ::fidl_next::Slot<'_, Self>,
10768 decoder_: &mut ___D,
10769 _: (),
10770 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10771 ::fidl_next::munge! {
10772 let Self {
10773
10774 mut id,
10775
10776 } = slot_;
10777 }
10778
10779 let _field = id.as_mut();
10780
10781 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10782
10783 Ok(())
10784 }
10785 }
10786
10787 impl ::fidl_next::IntoNatural for WrappedCapabilityId {
10788 type Natural = crate::natural::WrappedCapabilityId;
10789 }
10790
10791 impl ::fidl_next::Unconstrained for WrappedCapabilityId {}
10792
10793 pub type WrappedNewCapabilityId = crate::wire::WrappedCapabilityId;
10795
10796 #[derive(Debug)]
10798 #[repr(C)]
10799 pub struct CapabilityStoreDictionaryRemoveRequest<'de> {
10800 pub id: ::fidl_next::WireU64,
10801
10802 pub key: ::fidl_next::WireString<'de>,
10803
10804 pub dest_id: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
10805 }
10806
10807 static_assertions::const_assert_eq!(
10808 std::mem::size_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
10809 32
10810 );
10811 static_assertions::const_assert_eq!(
10812 std::mem::align_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
10813 8
10814 );
10815
10816 static_assertions::const_assert_eq!(
10817 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, id),
10818 0
10819 );
10820
10821 static_assertions::const_assert_eq!(
10822 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, key),
10823 8
10824 );
10825
10826 static_assertions::const_assert_eq!(
10827 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
10828 24
10829 );
10830
10831 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveRequest<'static> {
10832 type Decoded<'de> = CapabilityStoreDictionaryRemoveRequest<'de>;
10833
10834 #[inline]
10835 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10836 ::fidl_next::munge! {
10837 let Self {
10838
10839 id,
10840 key,
10841 dest_id,
10842
10843 } = &mut *out_;
10844 }
10845
10846 ::fidl_next::Wire::zero_padding(id);
10847
10848 ::fidl_next::Wire::zero_padding(key);
10849
10850 ::fidl_next::Wire::zero_padding(dest_id);
10851 }
10852 }
10853
10854 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveRequest<'static>
10855 where
10856 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10857 ___D: ::fidl_next::Decoder,
10858 {
10859 fn decode(
10860 slot_: ::fidl_next::Slot<'_, Self>,
10861 decoder_: &mut ___D,
10862 _: (),
10863 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10864 ::fidl_next::munge! {
10865 let Self {
10866
10867 mut id,
10868 mut key,
10869 mut dest_id,
10870
10871 } = slot_;
10872 }
10873
10874 let _field = id.as_mut();
10875
10876 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10877
10878 let _field = key.as_mut();
10879 ::fidl_next::Constrained::validate(_field, 255)?;
10880 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10881
10882 let key = unsafe { key.deref_unchecked() };
10883
10884 if key.len() > 255 {
10885 return Err(::fidl_next::DecodeError::VectorTooLong {
10886 size: key.len() as u64,
10887 limit: 255,
10888 });
10889 }
10890
10891 let _field = dest_id.as_mut();
10892
10893 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
10894
10895 Ok(())
10896 }
10897 }
10898
10899 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveRequest<'de> {
10900 type Natural = crate::natural::CapabilityStoreDictionaryRemoveRequest;
10901 }
10902
10903 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryRemoveRequest<'static> {}
10904
10905 #[derive(Clone, Debug)]
10907 #[repr(C)]
10908 pub struct CapabilityStoreDictionaryRemoveResponse {
10909 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10910 }
10911
10912 static_assertions::const_assert_eq!(
10913 std::mem::size_of::<CapabilityStoreDictionaryRemoveResponse>(),
10914 1
10915 );
10916 static_assertions::const_assert_eq!(
10917 std::mem::align_of::<CapabilityStoreDictionaryRemoveResponse>(),
10918 1
10919 );
10920
10921 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveResponse {
10922 type Decoded<'de> = CapabilityStoreDictionaryRemoveResponse;
10923
10924 #[inline]
10925 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10926 ::fidl_next::munge! {
10927 let Self {
10928
10929 _empty,
10930
10931
10932 } = &mut *out_;
10933 }
10934 }
10935 }
10936
10937 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveResponse
10938 where
10939 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10940 {
10941 fn decode(
10942 slot_: ::fidl_next::Slot<'_, Self>,
10943 decoder_: &mut ___D,
10944 _: (),
10945 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10946 ::fidl_next::munge! {
10947 let Self {
10948
10949 mut _empty,
10950
10951
10952 } = slot_;
10953 }
10954
10955 if _empty.as_bytes() != &[0u8] {
10956 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10957 }
10958
10959 Ok(())
10960 }
10961 }
10962
10963 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveResponse {
10964 type Natural = crate::natural::CapabilityStoreDictionaryRemoveResponse;
10965 }
10966
10967 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryRemoveResponse {}
10968
10969 #[derive(Clone, Debug)]
10971 #[repr(C)]
10972 pub struct CapabilityStoreDictionaryCopyRequest {
10973 pub id: ::fidl_next::WireU64,
10974
10975 pub dest_id: ::fidl_next::WireU64,
10976 }
10977
10978 static_assertions::const_assert_eq!(
10979 std::mem::size_of::<CapabilityStoreDictionaryCopyRequest>(),
10980 16
10981 );
10982 static_assertions::const_assert_eq!(
10983 std::mem::align_of::<CapabilityStoreDictionaryCopyRequest>(),
10984 8
10985 );
10986
10987 static_assertions::const_assert_eq!(
10988 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, id),
10989 0
10990 );
10991
10992 static_assertions::const_assert_eq!(
10993 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, dest_id),
10994 8
10995 );
10996
10997 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyRequest {
10998 type Decoded<'de> = CapabilityStoreDictionaryCopyRequest;
10999
11000 #[inline]
11001 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11002 ::fidl_next::munge! {
11003 let Self {
11004
11005 id,
11006 dest_id,
11007
11008 } = &mut *out_;
11009 }
11010
11011 ::fidl_next::Wire::zero_padding(id);
11012
11013 ::fidl_next::Wire::zero_padding(dest_id);
11014 }
11015 }
11016
11017 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyRequest
11018 where
11019 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11020 {
11021 fn decode(
11022 slot_: ::fidl_next::Slot<'_, Self>,
11023 decoder_: &mut ___D,
11024 _: (),
11025 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11026 ::fidl_next::munge! {
11027 let Self {
11028
11029 mut id,
11030 mut dest_id,
11031
11032 } = slot_;
11033 }
11034
11035 let _field = id.as_mut();
11036
11037 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11038
11039 let _field = dest_id.as_mut();
11040
11041 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
11042
11043 Ok(())
11044 }
11045 }
11046
11047 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyRequest {
11048 type Natural = crate::natural::CapabilityStoreDictionaryCopyRequest;
11049 }
11050
11051 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCopyRequest {}
11052
11053 #[derive(Clone, Debug)]
11055 #[repr(C)]
11056 pub struct CapabilityStoreDictionaryCopyResponse {
11057 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11058 }
11059
11060 static_assertions::const_assert_eq!(
11061 std::mem::size_of::<CapabilityStoreDictionaryCopyResponse>(),
11062 1
11063 );
11064 static_assertions::const_assert_eq!(
11065 std::mem::align_of::<CapabilityStoreDictionaryCopyResponse>(),
11066 1
11067 );
11068
11069 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyResponse {
11070 type Decoded<'de> = CapabilityStoreDictionaryCopyResponse;
11071
11072 #[inline]
11073 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11074 ::fidl_next::munge! {
11075 let Self {
11076
11077 _empty,
11078
11079
11080 } = &mut *out_;
11081 }
11082 }
11083 }
11084
11085 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyResponse
11086 where
11087 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11088 {
11089 fn decode(
11090 slot_: ::fidl_next::Slot<'_, Self>,
11091 decoder_: &mut ___D,
11092 _: (),
11093 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11094 ::fidl_next::munge! {
11095 let Self {
11096
11097 mut _empty,
11098
11099
11100 } = slot_;
11101 }
11102
11103 if _empty.as_bytes() != &[0u8] {
11104 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11105 }
11106
11107 Ok(())
11108 }
11109 }
11110
11111 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyResponse {
11112 type Natural = crate::natural::CapabilityStoreDictionaryCopyResponse;
11113 }
11114
11115 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCopyResponse {}
11116
11117 #[derive(Debug)]
11119 #[repr(C)]
11120 pub struct CapabilityStoreDictionaryKeysRequest {
11121 pub id: ::fidl_next::WireU64,
11122
11123 pub iterator: ::fidl_next::ServerEnd<
11124 crate::DictionaryKeysIterator,
11125 ::fidl_next::fuchsia::WireChannel,
11126 >,
11127 }
11128
11129 static_assertions::const_assert_eq!(
11130 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
11131 16
11132 );
11133 static_assertions::const_assert_eq!(
11134 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
11135 8
11136 );
11137
11138 static_assertions::const_assert_eq!(
11139 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
11140 0
11141 );
11142
11143 static_assertions::const_assert_eq!(
11144 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
11145 8
11146 );
11147
11148 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
11149 type Decoded<'de> = CapabilityStoreDictionaryKeysRequest;
11150
11151 #[inline]
11152 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11153 ::fidl_next::munge! {
11154 let Self {
11155
11156 id,
11157 iterator,
11158
11159 } = &mut *out_;
11160 }
11161
11162 ::fidl_next::Wire::zero_padding(id);
11163
11164 ::fidl_next::Wire::zero_padding(iterator);
11165
11166 unsafe {
11167 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11168 }
11169 }
11170 }
11171
11172 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
11173 where
11174 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11175 ___D: ::fidl_next::fuchsia::HandleDecoder,
11176 {
11177 fn decode(
11178 slot_: ::fidl_next::Slot<'_, Self>,
11179 decoder_: &mut ___D,
11180 _: (),
11181 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11182 if slot_.as_bytes()[12..16] != [0u8; 4] {
11183 return Err(::fidl_next::DecodeError::InvalidPadding);
11184 }
11185
11186 ::fidl_next::munge! {
11187 let Self {
11188
11189 mut id,
11190 mut iterator,
11191
11192 } = slot_;
11193 }
11194
11195 let _field = id.as_mut();
11196
11197 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11198
11199 let _field = iterator.as_mut();
11200
11201 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11202
11203 Ok(())
11204 }
11205 }
11206
11207 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
11208 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
11209 }
11210
11211 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysRequest {}
11212
11213 #[derive(Clone, Debug)]
11215 #[repr(C)]
11216 pub struct CapabilityStoreDictionaryKeysResponse {
11217 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11218 }
11219
11220 static_assertions::const_assert_eq!(
11221 std::mem::size_of::<CapabilityStoreDictionaryKeysResponse>(),
11222 1
11223 );
11224 static_assertions::const_assert_eq!(
11225 std::mem::align_of::<CapabilityStoreDictionaryKeysResponse>(),
11226 1
11227 );
11228
11229 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysResponse {
11230 type Decoded<'de> = CapabilityStoreDictionaryKeysResponse;
11231
11232 #[inline]
11233 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11234 ::fidl_next::munge! {
11235 let Self {
11236
11237 _empty,
11238
11239
11240 } = &mut *out_;
11241 }
11242 }
11243 }
11244
11245 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysResponse
11246 where
11247 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11248 {
11249 fn decode(
11250 slot_: ::fidl_next::Slot<'_, Self>,
11251 decoder_: &mut ___D,
11252 _: (),
11253 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11254 ::fidl_next::munge! {
11255 let Self {
11256
11257 mut _empty,
11258
11259
11260 } = slot_;
11261 }
11262
11263 if _empty.as_bytes() != &[0u8] {
11264 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11265 }
11266
11267 Ok(())
11268 }
11269 }
11270
11271 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysResponse {
11272 type Natural = crate::natural::CapabilityStoreDictionaryKeysResponse;
11273 }
11274
11275 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysResponse {}
11276
11277 #[derive(Debug)]
11279 #[repr(C)]
11280 pub struct CapabilityStoreDictionaryEnumerateRequest {
11281 pub id: ::fidl_next::WireU64,
11282
11283 pub iterator: ::fidl_next::ServerEnd<
11284 crate::DictionaryEnumerateIterator,
11285 ::fidl_next::fuchsia::WireChannel,
11286 >,
11287 }
11288
11289 static_assertions::const_assert_eq!(
11290 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
11291 16
11292 );
11293 static_assertions::const_assert_eq!(
11294 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
11295 8
11296 );
11297
11298 static_assertions::const_assert_eq!(
11299 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
11300 0
11301 );
11302
11303 static_assertions::const_assert_eq!(
11304 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
11305 8
11306 );
11307
11308 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
11309 type Decoded<'de> = CapabilityStoreDictionaryEnumerateRequest;
11310
11311 #[inline]
11312 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11313 ::fidl_next::munge! {
11314 let Self {
11315
11316 id,
11317 iterator,
11318
11319 } = &mut *out_;
11320 }
11321
11322 ::fidl_next::Wire::zero_padding(id);
11323
11324 ::fidl_next::Wire::zero_padding(iterator);
11325
11326 unsafe {
11327 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11328 }
11329 }
11330 }
11331
11332 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
11333 where
11334 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11335 ___D: ::fidl_next::fuchsia::HandleDecoder,
11336 {
11337 fn decode(
11338 slot_: ::fidl_next::Slot<'_, Self>,
11339 decoder_: &mut ___D,
11340 _: (),
11341 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11342 if slot_.as_bytes()[12..16] != [0u8; 4] {
11343 return Err(::fidl_next::DecodeError::InvalidPadding);
11344 }
11345
11346 ::fidl_next::munge! {
11347 let Self {
11348
11349 mut id,
11350 mut iterator,
11351
11352 } = slot_;
11353 }
11354
11355 let _field = id.as_mut();
11356
11357 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11358
11359 let _field = iterator.as_mut();
11360
11361 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11362
11363 Ok(())
11364 }
11365 }
11366
11367 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
11368 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
11369 }
11370
11371 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateRequest {}
11372
11373 #[derive(Clone, Debug)]
11375 #[repr(C)]
11376 pub struct CapabilityStoreDictionaryEnumerateResponse {
11377 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11378 }
11379
11380 static_assertions::const_assert_eq!(
11381 std::mem::size_of::<CapabilityStoreDictionaryEnumerateResponse>(),
11382 1
11383 );
11384 static_assertions::const_assert_eq!(
11385 std::mem::align_of::<CapabilityStoreDictionaryEnumerateResponse>(),
11386 1
11387 );
11388
11389 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateResponse {
11390 type Decoded<'de> = CapabilityStoreDictionaryEnumerateResponse;
11391
11392 #[inline]
11393 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11394 ::fidl_next::munge! {
11395 let Self {
11396
11397 _empty,
11398
11399
11400 } = &mut *out_;
11401 }
11402 }
11403 }
11404
11405 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateResponse
11406 where
11407 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11408 {
11409 fn decode(
11410 slot_: ::fidl_next::Slot<'_, Self>,
11411 decoder_: &mut ___D,
11412 _: (),
11413 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11414 ::fidl_next::munge! {
11415 let Self {
11416
11417 mut _empty,
11418
11419
11420 } = slot_;
11421 }
11422
11423 if _empty.as_bytes() != &[0u8] {
11424 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11425 }
11426
11427 Ok(())
11428 }
11429 }
11430
11431 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateResponse {
11432 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateResponse;
11433 }
11434
11435 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateResponse {}
11436
11437 #[derive(Debug)]
11439 #[repr(C)]
11440 pub struct CapabilityStoreDictionaryDrainRequest {
11441 pub id: ::fidl_next::WireU64,
11442
11443 pub iterator: ::fidl_next::ServerEnd<
11444 crate::DictionaryDrainIterator,
11445 ::fidl_next::fuchsia::WireOptionalChannel,
11446 >,
11447 }
11448
11449 static_assertions::const_assert_eq!(
11450 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
11451 16
11452 );
11453 static_assertions::const_assert_eq!(
11454 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
11455 8
11456 );
11457
11458 static_assertions::const_assert_eq!(
11459 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
11460 0
11461 );
11462
11463 static_assertions::const_assert_eq!(
11464 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
11465 8
11466 );
11467
11468 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
11469 type Decoded<'de> = CapabilityStoreDictionaryDrainRequest;
11470
11471 #[inline]
11472 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11473 ::fidl_next::munge! {
11474 let Self {
11475
11476 id,
11477 iterator,
11478
11479 } = &mut *out_;
11480 }
11481
11482 ::fidl_next::Wire::zero_padding(id);
11483
11484 ::fidl_next::Wire::zero_padding(iterator);
11485
11486 unsafe {
11487 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11488 }
11489 }
11490 }
11491
11492 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
11493 where
11494 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11495 ___D: ::fidl_next::fuchsia::HandleDecoder,
11496 {
11497 fn decode(
11498 slot_: ::fidl_next::Slot<'_, Self>,
11499 decoder_: &mut ___D,
11500 _: (),
11501 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11502 if slot_.as_bytes()[12..16] != [0u8; 4] {
11503 return Err(::fidl_next::DecodeError::InvalidPadding);
11504 }
11505
11506 ::fidl_next::munge! {
11507 let Self {
11508
11509 mut id,
11510 mut iterator,
11511
11512 } = slot_;
11513 }
11514
11515 let _field = id.as_mut();
11516
11517 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11518
11519 let _field = iterator.as_mut();
11520
11521 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11522
11523 Ok(())
11524 }
11525 }
11526
11527 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
11528 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
11529 }
11530
11531 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainRequest {}
11532
11533 #[derive(Clone, Debug)]
11535 #[repr(C)]
11536 pub struct CapabilityStoreDictionaryDrainResponse {
11537 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11538 }
11539
11540 static_assertions::const_assert_eq!(
11541 std::mem::size_of::<CapabilityStoreDictionaryDrainResponse>(),
11542 1
11543 );
11544 static_assertions::const_assert_eq!(
11545 std::mem::align_of::<CapabilityStoreDictionaryDrainResponse>(),
11546 1
11547 );
11548
11549 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainResponse {
11550 type Decoded<'de> = CapabilityStoreDictionaryDrainResponse;
11551
11552 #[inline]
11553 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11554 ::fidl_next::munge! {
11555 let Self {
11556
11557 _empty,
11558
11559
11560 } = &mut *out_;
11561 }
11562 }
11563 }
11564
11565 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainResponse
11566 where
11567 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11568 {
11569 fn decode(
11570 slot_: ::fidl_next::Slot<'_, Self>,
11571 decoder_: &mut ___D,
11572 _: (),
11573 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11574 ::fidl_next::munge! {
11575 let Self {
11576
11577 mut _empty,
11578
11579
11580 } = slot_;
11581 }
11582
11583 if _empty.as_bytes() != &[0u8] {
11584 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11585 }
11586
11587 Ok(())
11588 }
11589 }
11590
11591 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainResponse {
11592 type Natural = crate::natural::CapabilityStoreDictionaryDrainResponse;
11593 }
11594
11595 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainResponse {}
11596
11597 #[derive(Debug)]
11599 #[repr(C)]
11600 pub struct CapabilityStoreExportResponse<'de> {
11601 pub capability: crate::wire::Capability<'de>,
11602 }
11603
11604 static_assertions::const_assert_eq!(
11605 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
11606 16
11607 );
11608 static_assertions::const_assert_eq!(
11609 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
11610 8
11611 );
11612
11613 static_assertions::const_assert_eq!(
11614 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
11615 0
11616 );
11617
11618 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
11619 type Decoded<'de> = CapabilityStoreExportResponse<'de>;
11620
11621 #[inline]
11622 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11623 ::fidl_next::munge! {
11624 let Self {
11625
11626 capability,
11627
11628 } = &mut *out_;
11629 }
11630
11631 ::fidl_next::Wire::zero_padding(capability);
11632 }
11633 }
11634
11635 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'static>
11636 where
11637 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11638 ___D: ::fidl_next::Decoder,
11639 ___D: ::fidl_next::fuchsia::HandleDecoder,
11640 {
11641 fn decode(
11642 slot_: ::fidl_next::Slot<'_, Self>,
11643 decoder_: &mut ___D,
11644 _: (),
11645 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11646 ::fidl_next::munge! {
11647 let Self {
11648
11649 mut capability,
11650
11651 } = slot_;
11652 }
11653
11654 let _field = capability.as_mut();
11655
11656 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
11657
11658 Ok(())
11659 }
11660 }
11661
11662 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
11663 type Natural = crate::natural::CapabilityStoreExportResponse;
11664 }
11665
11666 impl ::fidl_next::Unconstrained for CapabilityStoreExportResponse<'static> {}
11667
11668 #[derive(Debug)]
11670 #[repr(C)]
11671 pub struct CapabilityStoreImportRequest<'de> {
11672 pub id: ::fidl_next::WireU64,
11673
11674 pub capability: crate::wire::Capability<'de>,
11675 }
11676
11677 static_assertions::const_assert_eq!(
11678 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
11679 24
11680 );
11681 static_assertions::const_assert_eq!(
11682 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
11683 8
11684 );
11685
11686 static_assertions::const_assert_eq!(
11687 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
11688 0
11689 );
11690
11691 static_assertions::const_assert_eq!(
11692 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
11693 8
11694 );
11695
11696 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
11697 type Decoded<'de> = CapabilityStoreImportRequest<'de>;
11698
11699 #[inline]
11700 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11701 ::fidl_next::munge! {
11702 let Self {
11703
11704 id,
11705 capability,
11706
11707 } = &mut *out_;
11708 }
11709
11710 ::fidl_next::Wire::zero_padding(id);
11711
11712 ::fidl_next::Wire::zero_padding(capability);
11713 }
11714 }
11715
11716 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'static>
11717 where
11718 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11719 ___D: ::fidl_next::Decoder,
11720 ___D: ::fidl_next::fuchsia::HandleDecoder,
11721 {
11722 fn decode(
11723 slot_: ::fidl_next::Slot<'_, Self>,
11724 decoder_: &mut ___D,
11725 _: (),
11726 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11727 ::fidl_next::munge! {
11728 let Self {
11729
11730 mut id,
11731 mut capability,
11732
11733 } = slot_;
11734 }
11735
11736 let _field = id.as_mut();
11737
11738 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11739
11740 let _field = capability.as_mut();
11741
11742 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
11743
11744 Ok(())
11745 }
11746 }
11747
11748 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
11749 type Natural = crate::natural::CapabilityStoreImportRequest;
11750 }
11751
11752 impl ::fidl_next::Unconstrained for CapabilityStoreImportRequest<'static> {}
11753
11754 #[derive(Debug)]
11756 #[repr(C)]
11757 pub struct CapabilityStoreDirConnectorCreateRequest {
11758 pub id: ::fidl_next::WireU64,
11759
11760 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
11761 }
11762
11763 static_assertions::const_assert_eq!(
11764 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
11765 16
11766 );
11767 static_assertions::const_assert_eq!(
11768 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
11769 8
11770 );
11771
11772 static_assertions::const_assert_eq!(
11773 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
11774 0
11775 );
11776
11777 static_assertions::const_assert_eq!(
11778 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
11779 8
11780 );
11781
11782 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
11783 type Decoded<'de> = CapabilityStoreDirConnectorCreateRequest;
11784
11785 #[inline]
11786 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11787 ::fidl_next::munge! {
11788 let Self {
11789
11790 id,
11791 receiver,
11792
11793 } = &mut *out_;
11794 }
11795
11796 ::fidl_next::Wire::zero_padding(id);
11797
11798 ::fidl_next::Wire::zero_padding(receiver);
11799
11800 unsafe {
11801 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11802 }
11803 }
11804 }
11805
11806 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
11807 where
11808 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11809 ___D: ::fidl_next::fuchsia::HandleDecoder,
11810 {
11811 fn decode(
11812 slot_: ::fidl_next::Slot<'_, Self>,
11813 decoder_: &mut ___D,
11814 _: (),
11815 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11816 if slot_.as_bytes()[12..16] != [0u8; 4] {
11817 return Err(::fidl_next::DecodeError::InvalidPadding);
11818 }
11819
11820 ::fidl_next::munge! {
11821 let Self {
11822
11823 mut id,
11824 mut receiver,
11825
11826 } = slot_;
11827 }
11828
11829 let _field = id.as_mut();
11830
11831 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11832
11833 let _field = receiver.as_mut();
11834
11835 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
11836
11837 Ok(())
11838 }
11839 }
11840
11841 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
11842 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
11843 }
11844
11845 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateRequest {}
11846
11847 #[derive(Debug)]
11849 #[repr(C)]
11850 pub struct CapabilityStoreDirConnectorOpenRequest {
11851 pub id: ::fidl_next::WireU64,
11852
11853 pub server_end: ::fidl_next::ServerEnd<
11854 ::fidl_next_fuchsia_io::Directory,
11855 ::fidl_next::fuchsia::WireChannel,
11856 >,
11857 }
11858
11859 static_assertions::const_assert_eq!(
11860 std::mem::size_of::<CapabilityStoreDirConnectorOpenRequest>(),
11861 16
11862 );
11863 static_assertions::const_assert_eq!(
11864 std::mem::align_of::<CapabilityStoreDirConnectorOpenRequest>(),
11865 8
11866 );
11867
11868 static_assertions::const_assert_eq!(
11869 std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, id),
11870 0
11871 );
11872
11873 static_assertions::const_assert_eq!(
11874 std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, server_end),
11875 8
11876 );
11877
11878 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest {
11879 type Decoded<'de> = CapabilityStoreDirConnectorOpenRequest;
11880
11881 #[inline]
11882 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11883 ::fidl_next::munge! {
11884 let Self {
11885
11886 id,
11887 server_end,
11888
11889 } = &mut *out_;
11890 }
11891
11892 ::fidl_next::Wire::zero_padding(id);
11893
11894 ::fidl_next::Wire::zero_padding(server_end);
11895
11896 unsafe {
11897 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11898 }
11899 }
11900 }
11901
11902 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest
11903 where
11904 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11905 ___D: ::fidl_next::fuchsia::HandleDecoder,
11906 {
11907 fn decode(
11908 slot_: ::fidl_next::Slot<'_, Self>,
11909 decoder_: &mut ___D,
11910 _: (),
11911 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11912 if slot_.as_bytes()[12..16] != [0u8; 4] {
11913 return Err(::fidl_next::DecodeError::InvalidPadding);
11914 }
11915
11916 ::fidl_next::munge! {
11917 let Self {
11918
11919 mut id,
11920 mut server_end,
11921
11922 } = slot_;
11923 }
11924
11925 let _field = id.as_mut();
11926
11927 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11928
11929 let _field = server_end.as_mut();
11930
11931 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
11932
11933 Ok(())
11934 }
11935 }
11936
11937 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest {
11938 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
11939 }
11940
11941 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenRequest {}
11942
11943 #[derive(Debug)]
11945 #[repr(C)]
11946 pub struct InstanceToken {
11947 pub token: ::fidl_next::fuchsia::WireEventPair,
11948 }
11949
11950 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
11951 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
11952
11953 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
11954
11955 unsafe impl ::fidl_next::Wire for InstanceToken {
11956 type Decoded<'de> = InstanceToken;
11957
11958 #[inline]
11959 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11960 ::fidl_next::munge! {
11961 let Self {
11962
11963 token,
11964
11965 } = &mut *out_;
11966 }
11967
11968 ::fidl_next::Wire::zero_padding(token);
11969 }
11970 }
11971
11972 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
11973 where
11974 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11975 ___D: ::fidl_next::fuchsia::HandleDecoder,
11976 {
11977 fn decode(
11978 slot_: ::fidl_next::Slot<'_, Self>,
11979 decoder_: &mut ___D,
11980 _: (),
11981 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11982 ::fidl_next::munge! {
11983 let Self {
11984
11985 mut token,
11986
11987 } = slot_;
11988 }
11989
11990 let _field = token.as_mut();
11991
11992 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
11993
11994 Ok(())
11995 }
11996 }
11997
11998 impl ::fidl_next::IntoNatural for InstanceToken {
11999 type Natural = crate::natural::InstanceToken;
12000 }
12001
12002 impl ::fidl_next::Unconstrained for InstanceToken {}
12003
12004 #[repr(C)]
12006 pub struct RouteRequest<'de> {
12007 pub(crate) table: ::fidl_next::WireTable<'de>,
12008 }
12009
12010 impl<'de> Drop for RouteRequest<'de> {
12011 fn drop(&mut self) {
12012 let _ = self
12013 .table
12014 .get(1)
12015 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
12016
12017 let _ = self
12018 .table
12019 .get(2)
12020 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
12021 }
12022 }
12023
12024 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
12025 type Decoded<'de> = RouteRequest<'de>;
12026
12027 #[inline]
12028 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12029 ::fidl_next::munge!(let Self { table } = out);
12030 ::fidl_next::WireTable::zero_padding(table);
12031 }
12032 }
12033
12034 unsafe impl<___D> ::fidl_next::Decode<___D> for RouteRequest<'static>
12035 where
12036 ___D: ::fidl_next::Decoder + ?Sized,
12037 ___D: ::fidl_next::fuchsia::HandleDecoder,
12038 {
12039 fn decode(
12040 slot: ::fidl_next::Slot<'_, Self>,
12041 decoder: &mut ___D,
12042 _: (),
12043 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12044 ::fidl_next::munge!(let Self { table } = slot);
12045
12046 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
12047 match ordinal {
12048 0 => unsafe { ::core::hint::unreachable_unchecked() },
12049
12050 1 => {
12051 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::InstanceToken>(
12052 slot.as_mut(),
12053 decoder,
12054 (),
12055 )?;
12056
12057 Ok(())
12058 }
12059
12060 2 => {
12061 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DictionaryRef>(
12062 slot.as_mut(),
12063 decoder,
12064 (),
12065 )?;
12066
12067 Ok(())
12068 }
12069
12070 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
12071 }
12072 })
12073 }
12074 }
12075
12076 impl<'de> RouteRequest<'de> {
12077 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
12078 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
12079 }
12080
12081 pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
12082 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
12083 }
12084 }
12085
12086 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
12087 fn fmt(
12088 &self,
12089 f: &mut ::core::fmt::Formatter<'_>,
12090 ) -> ::core::result::Result<(), ::core::fmt::Error> {
12091 f.debug_struct("RouteRequest")
12092 .field("requesting", &self.requesting())
12093 .field("metadata", &self.metadata())
12094 .finish()
12095 }
12096 }
12097
12098 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
12099 type Natural = crate::natural::RouteRequest;
12100 }
12101
12102 impl ::fidl_next::Unconstrained for RouteRequest<'_> {}
12103
12104 #[repr(transparent)]
12106 pub struct ConnectorRouterRouteResponse {
12107 pub(crate) raw: ::fidl_next::RawWireUnion,
12108 pub(crate) _phantom: ::core::marker::PhantomData<()>,
12109 }
12110
12111 impl Drop for ConnectorRouterRouteResponse {
12112 fn drop(&mut self) {
12113 match self.raw.ordinal() {
12114 1 => {
12115 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
12116 }
12117
12118 2 => {
12119 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
12120 }
12121
12122 _ => unsafe { ::core::hint::unreachable_unchecked() },
12123 }
12124 }
12125 }
12126
12127 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
12128 type Decoded<'de> = ConnectorRouterRouteResponse;
12129
12130 #[inline]
12131 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12132 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12133 ::fidl_next::RawWireUnion::zero_padding(raw);
12134 }
12135 }
12136
12137 pub mod connector_router_route_response {
12138 pub enum Ref<'de> {
12139 Connector(&'de crate::wire::Connector),
12140
12141 Unavailable(&'de crate::wire::Unit),
12142 }
12143 }
12144
12145 impl ConnectorRouterRouteResponse {
12146 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
12147 match self.raw.ordinal() {
12148 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
12149 self.raw.get().deref_unchecked::<crate::wire::Connector>()
12150 }),
12151
12152 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
12153 self.raw.get().deref_unchecked::<crate::wire::Unit>()
12154 }),
12155
12156 _ => unsafe { ::core::hint::unreachable_unchecked() },
12157 }
12158 }
12159 }
12160
12161 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
12162 where
12163 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12164 ___D: ::fidl_next::fuchsia::HandleDecoder,
12165 {
12166 fn decode(
12167 mut slot: ::fidl_next::Slot<'_, Self>,
12168 decoder: &mut ___D,
12169 _: (),
12170 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12171 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12172 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12173 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
12174 raw,
12175 decoder,
12176 (),
12177 )?,
12178
12179 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
12180 raw,
12181 decoder,
12182 (),
12183 )?,
12184
12185 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12186 }
12187
12188 Ok(())
12189 }
12190 }
12191
12192 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
12193 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12194 match self.raw.ordinal() {
12195 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
12196 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
12197 _ => unsafe { ::core::hint::unreachable_unchecked() },
12198 }
12199 }
12200 }
12201
12202 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
12203 type Natural = crate::natural::ConnectorRouterRouteResponse;
12204 }
12205
12206 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
12207
12208 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12210 #[repr(transparent)]
12211 pub struct RouterError {
12212 pub(crate) value: ::fidl_next::WireU32,
12213 }
12214
12215 unsafe impl ::fidl_next::Wire for RouterError {
12216 type Decoded<'de> = Self;
12217
12218 #[inline]
12219 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12220 }
12222 }
12223
12224 impl RouterError {
12225 pub const NOT_FOUND: RouterError = RouterError { value: ::fidl_next::WireU32(1) };
12226
12227 pub const INVALID_ARGS: RouterError = RouterError { value: ::fidl_next::WireU32(2) };
12228
12229 pub const NOT_SUPPORTED: RouterError = RouterError { value: ::fidl_next::WireU32(3) };
12230
12231 pub const INTERNAL: RouterError = RouterError { value: ::fidl_next::WireU32(4) };
12232 }
12233
12234 unsafe impl<___D> ::fidl_next::Decode<___D> for RouterError
12235 where
12236 ___D: ?Sized,
12237 {
12238 fn decode(
12239 slot: ::fidl_next::Slot<'_, Self>,
12240 _: &mut ___D,
12241 _: (),
12242 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12243 Ok(())
12244 }
12245 }
12246
12247 impl ::core::convert::From<crate::natural::RouterError> for RouterError {
12248 fn from(natural: crate::natural::RouterError) -> Self {
12249 match natural {
12250 crate::natural::RouterError::NotFound => RouterError::NOT_FOUND,
12251
12252 crate::natural::RouterError::InvalidArgs => RouterError::INVALID_ARGS,
12253
12254 crate::natural::RouterError::NotSupported => RouterError::NOT_SUPPORTED,
12255
12256 crate::natural::RouterError::Internal => RouterError::INTERNAL,
12257
12258 crate::natural::RouterError::UnknownOrdinal_(value) => {
12259 RouterError { value: ::fidl_next::WireU32::from(value) }
12260 }
12261 }
12262 }
12263 }
12264
12265 impl ::fidl_next::IntoNatural for RouterError {
12266 type Natural = crate::natural::RouterError;
12267 }
12268
12269 impl ::fidl_next::Unconstrained for RouterError {}
12270
12271 #[repr(transparent)]
12273 pub struct DataRouterRouteResponse<'de> {
12274 pub(crate) raw: ::fidl_next::RawWireUnion,
12275 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12276 }
12277
12278 impl<'de> Drop for DataRouterRouteResponse<'de> {
12279 fn drop(&mut self) {
12280 match self.raw.ordinal() {
12281 1 => {
12282 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
12283 }
12284
12285 2 => {
12286 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
12287 }
12288
12289 _ => unsafe { ::core::hint::unreachable_unchecked() },
12290 }
12291 }
12292 }
12293
12294 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
12295 type Decoded<'de> = DataRouterRouteResponse<'de>;
12296
12297 #[inline]
12298 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12299 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12300 ::fidl_next::RawWireUnion::zero_padding(raw);
12301 }
12302 }
12303
12304 pub mod data_router_route_response {
12305 pub enum Ref<'de> {
12306 Data(&'de crate::wire::Data<'de>),
12307
12308 Unavailable(&'de crate::wire::Unit),
12309 }
12310 }
12311
12312 impl<'de> DataRouterRouteResponse<'de> {
12313 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
12314 match self.raw.ordinal() {
12315 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
12316 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
12317 }),
12318
12319 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
12320 self.raw.get().deref_unchecked::<crate::wire::Unit>()
12321 }),
12322
12323 _ => unsafe { ::core::hint::unreachable_unchecked() },
12324 }
12325 }
12326 }
12327
12328 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
12329 where
12330 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12331 ___D: ::fidl_next::Decoder,
12332 ___D: ::fidl_next::fuchsia::HandleDecoder,
12333 {
12334 fn decode(
12335 mut slot: ::fidl_next::Slot<'_, Self>,
12336 decoder: &mut ___D,
12337 _: (),
12338 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12339 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12340 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12341 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
12342 raw,
12343 decoder,
12344 (),
12345 )?,
12346
12347 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
12348 raw,
12349 decoder,
12350 (),
12351 )?,
12352
12353 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12354 }
12355
12356 Ok(())
12357 }
12358 }
12359
12360 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
12361 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12362 match self.raw.ordinal() {
12363 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
12364 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
12365 _ => unsafe { ::core::hint::unreachable_unchecked() },
12366 }
12367 }
12368 }
12369
12370 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
12371 type Natural = crate::natural::DataRouterRouteResponse;
12372 }
12373
12374 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
12375
12376 #[derive(Clone, Debug)]
12378 #[repr(C)]
12379 pub struct DictionaryDrainIteratorGetNextRequest {
12380 pub start_id: ::fidl_next::WireU64,
12381
12382 pub limit: ::fidl_next::WireU32,
12383 }
12384
12385 static_assertions::const_assert_eq!(
12386 std::mem::size_of::<DictionaryDrainIteratorGetNextRequest>(),
12387 16
12388 );
12389 static_assertions::const_assert_eq!(
12390 std::mem::align_of::<DictionaryDrainIteratorGetNextRequest>(),
12391 8
12392 );
12393
12394 static_assertions::const_assert_eq!(
12395 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, start_id),
12396 0
12397 );
12398
12399 static_assertions::const_assert_eq!(
12400 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, limit),
12401 8
12402 );
12403
12404 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextRequest {
12405 type Decoded<'de> = DictionaryDrainIteratorGetNextRequest;
12406
12407 #[inline]
12408 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12409 ::fidl_next::munge! {
12410 let Self {
12411
12412 start_id,
12413 limit,
12414
12415 } = &mut *out_;
12416 }
12417
12418 ::fidl_next::Wire::zero_padding(start_id);
12419
12420 ::fidl_next::Wire::zero_padding(limit);
12421
12422 unsafe {
12423 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
12424 }
12425 }
12426 }
12427
12428 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextRequest
12429 where
12430 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12431 {
12432 fn decode(
12433 slot_: ::fidl_next::Slot<'_, Self>,
12434 decoder_: &mut ___D,
12435 _: (),
12436 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12437 if slot_.as_bytes()[12..16] != [0u8; 4] {
12438 return Err(::fidl_next::DecodeError::InvalidPadding);
12439 }
12440
12441 ::fidl_next::munge! {
12442 let Self {
12443
12444 mut start_id,
12445 mut limit,
12446
12447 } = slot_;
12448 }
12449
12450 let _field = start_id.as_mut();
12451
12452 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
12453
12454 let _field = limit.as_mut();
12455
12456 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
12457
12458 Ok(())
12459 }
12460 }
12461
12462 impl ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextRequest {
12463 type Natural = crate::natural::DictionaryDrainIteratorGetNextRequest;
12464 }
12465
12466 impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextRequest {}
12467
12468 #[derive(Debug)]
12470 #[repr(C)]
12471 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
12472 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryItem<'de>>,
12473
12474 pub end_id: ::fidl_next::WireU64,
12475 }
12476
12477 static_assertions::const_assert_eq!(
12478 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
12479 24
12480 );
12481 static_assertions::const_assert_eq!(
12482 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
12483 8
12484 );
12485
12486 static_assertions::const_assert_eq!(
12487 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
12488 0
12489 );
12490
12491 static_assertions::const_assert_eq!(
12492 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
12493 16
12494 );
12495
12496 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
12497 type Decoded<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
12498
12499 #[inline]
12500 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12501 ::fidl_next::munge! {
12502 let Self {
12503
12504 items,
12505 end_id,
12506
12507 } = &mut *out_;
12508 }
12509
12510 ::fidl_next::Wire::zero_padding(items);
12511
12512 ::fidl_next::Wire::zero_padding(end_id);
12513 }
12514 }
12515
12516 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'static>
12517 where
12518 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12519 ___D: ::fidl_next::Decoder,
12520 ___D: ::fidl_next::fuchsia::HandleDecoder,
12521 {
12522 fn decode(
12523 slot_: ::fidl_next::Slot<'_, Self>,
12524 decoder_: &mut ___D,
12525 _: (),
12526 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12527 ::fidl_next::munge! {
12528 let Self {
12529
12530 mut items,
12531 mut end_id,
12532
12533 } = slot_;
12534 }
12535
12536 let _field = items.as_mut();
12537 ::fidl_next::Constrained::validate(_field, (128, ()))?;
12538 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
12539
12540 let items = unsafe { items.deref_unchecked() };
12541
12542 if items.len() > 128 {
12543 return Err(::fidl_next::DecodeError::VectorTooLong {
12544 size: items.len() as u64,
12545 limit: 128,
12546 });
12547 }
12548
12549 let _field = end_id.as_mut();
12550
12551 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
12552
12553 Ok(())
12554 }
12555 }
12556
12557 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
12558 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
12559 }
12560
12561 impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextResponse<'static> {}
12562
12563 #[derive(Clone, Debug)]
12565 #[repr(C)]
12566 pub struct DictionaryEnumerateIteratorGetNextRequest {
12567 pub start_id: ::fidl_next::WireU64,
12568
12569 pub limit: ::fidl_next::WireU32,
12570 }
12571
12572 static_assertions::const_assert_eq!(
12573 std::mem::size_of::<DictionaryEnumerateIteratorGetNextRequest>(),
12574 16
12575 );
12576 static_assertions::const_assert_eq!(
12577 std::mem::align_of::<DictionaryEnumerateIteratorGetNextRequest>(),
12578 8
12579 );
12580
12581 static_assertions::const_assert_eq!(
12582 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, start_id),
12583 0
12584 );
12585
12586 static_assertions::const_assert_eq!(
12587 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, limit),
12588 8
12589 );
12590
12591 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextRequest {
12592 type Decoded<'de> = DictionaryEnumerateIteratorGetNextRequest;
12593
12594 #[inline]
12595 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12596 ::fidl_next::munge! {
12597 let Self {
12598
12599 start_id,
12600 limit,
12601
12602 } = &mut *out_;
12603 }
12604
12605 ::fidl_next::Wire::zero_padding(start_id);
12606
12607 ::fidl_next::Wire::zero_padding(limit);
12608
12609 unsafe {
12610 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
12611 }
12612 }
12613 }
12614
12615 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextRequest
12616 where
12617 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12618 {
12619 fn decode(
12620 slot_: ::fidl_next::Slot<'_, Self>,
12621 decoder_: &mut ___D,
12622 _: (),
12623 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12624 if slot_.as_bytes()[12..16] != [0u8; 4] {
12625 return Err(::fidl_next::DecodeError::InvalidPadding);
12626 }
12627
12628 ::fidl_next::munge! {
12629 let Self {
12630
12631 mut start_id,
12632 mut limit,
12633
12634 } = slot_;
12635 }
12636
12637 let _field = start_id.as_mut();
12638
12639 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
12640
12641 let _field = limit.as_mut();
12642
12643 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
12644
12645 Ok(())
12646 }
12647 }
12648
12649 impl ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextRequest {
12650 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextRequest;
12651 }
12652
12653 impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextRequest {}
12654
12655 #[derive(Debug)]
12657 #[repr(C)]
12658 pub struct DictionaryOptionalItem<'de> {
12659 pub key: ::fidl_next::WireString<'de>,
12660
12661 pub value: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
12662 }
12663
12664 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
12665 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
12666
12667 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
12668
12669 static_assertions::const_assert_eq!(
12670 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
12671 16
12672 );
12673
12674 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
12675 type Decoded<'de> = DictionaryOptionalItem<'de>;
12676
12677 #[inline]
12678 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12679 ::fidl_next::munge! {
12680 let Self {
12681
12682 key,
12683 value,
12684
12685 } = &mut *out_;
12686 }
12687
12688 ::fidl_next::Wire::zero_padding(key);
12689
12690 ::fidl_next::Wire::zero_padding(value);
12691 }
12692 }
12693
12694 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'static>
12695 where
12696 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12697 ___D: ::fidl_next::Decoder,
12698 ___D: ::fidl_next::fuchsia::HandleDecoder,
12699 {
12700 fn decode(
12701 slot_: ::fidl_next::Slot<'_, Self>,
12702 decoder_: &mut ___D,
12703 _: (),
12704 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12705 ::fidl_next::munge! {
12706 let Self {
12707
12708 mut key,
12709 mut value,
12710
12711 } = slot_;
12712 }
12713
12714 let _field = key.as_mut();
12715 ::fidl_next::Constrained::validate(_field, 255)?;
12716 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
12717
12718 let key = unsafe { key.deref_unchecked() };
12719
12720 if key.len() > 255 {
12721 return Err(::fidl_next::DecodeError::VectorTooLong {
12722 size: key.len() as u64,
12723 limit: 255,
12724 });
12725 }
12726
12727 let _field = value.as_mut();
12728
12729 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
12730
12731 Ok(())
12732 }
12733 }
12734
12735 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
12736 type Natural = crate::natural::DictionaryOptionalItem;
12737 }
12738
12739 impl ::fidl_next::Unconstrained for DictionaryOptionalItem<'static> {}
12740
12741 #[derive(Debug)]
12743 #[repr(C)]
12744 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
12745 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryOptionalItem<'de>>,
12746
12747 pub end_id: ::fidl_next::WireU64,
12748 }
12749
12750 static_assertions::const_assert_eq!(
12751 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
12752 24
12753 );
12754 static_assertions::const_assert_eq!(
12755 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
12756 8
12757 );
12758
12759 static_assertions::const_assert_eq!(
12760 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
12761 0
12762 );
12763
12764 static_assertions::const_assert_eq!(
12765 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
12766 16
12767 );
12768
12769 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
12770 type Decoded<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
12771
12772 #[inline]
12773 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12774 ::fidl_next::munge! {
12775 let Self {
12776
12777 items,
12778 end_id,
12779
12780 } = &mut *out_;
12781 }
12782
12783 ::fidl_next::Wire::zero_padding(items);
12784
12785 ::fidl_next::Wire::zero_padding(end_id);
12786 }
12787 }
12788
12789 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'static>
12790 where
12791 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12792 ___D: ::fidl_next::Decoder,
12793 ___D: ::fidl_next::fuchsia::HandleDecoder,
12794 {
12795 fn decode(
12796 slot_: ::fidl_next::Slot<'_, Self>,
12797 decoder_: &mut ___D,
12798 _: (),
12799 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12800 ::fidl_next::munge! {
12801 let Self {
12802
12803 mut items,
12804 mut end_id,
12805
12806 } = slot_;
12807 }
12808
12809 let _field = items.as_mut();
12810 ::fidl_next::Constrained::validate(_field, (128, ()))?;
12811 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
12812
12813 let items = unsafe { items.deref_unchecked() };
12814
12815 if items.len() > 128 {
12816 return Err(::fidl_next::DecodeError::VectorTooLong {
12817 size: items.len() as u64,
12818 limit: 128,
12819 });
12820 }
12821
12822 let _field = end_id.as_mut();
12823
12824 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
12825
12826 Ok(())
12827 }
12828 }
12829
12830 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
12831 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
12832 }
12833
12834 impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextResponse<'static> {}
12835
12836 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12838 #[repr(transparent)]
12839 pub struct DictionaryError {
12840 pub(crate) value: ::fidl_next::WireU32,
12841 }
12842
12843 unsafe impl ::fidl_next::Wire for DictionaryError {
12844 type Decoded<'de> = Self;
12845
12846 #[inline]
12847 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12848 }
12850 }
12851
12852 impl DictionaryError {
12853 pub const NOT_FOUND: DictionaryError = DictionaryError { value: ::fidl_next::WireU32(1) };
12854
12855 pub const ALREADY_EXISTS: DictionaryError =
12856 DictionaryError { value: ::fidl_next::WireU32(2) };
12857
12858 pub const BAD_CAPABILITY: DictionaryError =
12859 DictionaryError { value: ::fidl_next::WireU32(3) };
12860
12861 pub const INVALID_KEY: DictionaryError = DictionaryError { value: ::fidl_next::WireU32(4) };
12862
12863 pub const NOT_CLONEABLE: DictionaryError =
12864 DictionaryError { value: ::fidl_next::WireU32(5) };
12865 }
12866
12867 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryError
12868 where
12869 ___D: ?Sized,
12870 {
12871 fn decode(
12872 slot: ::fidl_next::Slot<'_, Self>,
12873 _: &mut ___D,
12874 _: (),
12875 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12876 Ok(())
12877 }
12878 }
12879
12880 impl ::core::convert::From<crate::natural::DictionaryError> for DictionaryError {
12881 fn from(natural: crate::natural::DictionaryError) -> Self {
12882 match natural {
12883 crate::natural::DictionaryError::NotFound => DictionaryError::NOT_FOUND,
12884
12885 crate::natural::DictionaryError::AlreadyExists => DictionaryError::ALREADY_EXISTS,
12886
12887 crate::natural::DictionaryError::BadCapability => DictionaryError::BAD_CAPABILITY,
12888
12889 crate::natural::DictionaryError::InvalidKey => DictionaryError::INVALID_KEY,
12890
12891 crate::natural::DictionaryError::NotCloneable => DictionaryError::NOT_CLONEABLE,
12892
12893 crate::natural::DictionaryError::UnknownOrdinal_(value) => {
12894 DictionaryError { value: ::fidl_next::WireU32::from(value) }
12895 }
12896 }
12897 }
12898 }
12899
12900 impl ::fidl_next::IntoNatural for DictionaryError {
12901 type Natural = crate::natural::DictionaryError;
12902 }
12903
12904 impl ::fidl_next::Unconstrained for DictionaryError {}
12905
12906 #[derive(Debug)]
12908 #[repr(C)]
12909 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
12910 pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
12911 }
12912
12913 static_assertions::const_assert_eq!(
12914 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
12915 16
12916 );
12917 static_assertions::const_assert_eq!(
12918 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
12919 8
12920 );
12921
12922 static_assertions::const_assert_eq!(
12923 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
12924 0
12925 );
12926
12927 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
12928 type Decoded<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
12929
12930 #[inline]
12931 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12932 ::fidl_next::munge! {
12933 let Self {
12934
12935 keys,
12936
12937 } = &mut *out_;
12938 }
12939
12940 ::fidl_next::Wire::zero_padding(keys);
12941 }
12942 }
12943
12944 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'static>
12945 where
12946 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12947 ___D: ::fidl_next::Decoder,
12948 ___D: ::fidl_next::fuchsia::HandleDecoder,
12949 {
12950 fn decode(
12951 slot_: ::fidl_next::Slot<'_, Self>,
12952 decoder_: &mut ___D,
12953 _: (),
12954 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12955 ::fidl_next::munge! {
12956 let Self {
12957
12958 mut keys,
12959
12960 } = slot_;
12961 }
12962
12963 let _field = keys.as_mut();
12964 ::fidl_next::Constrained::validate(_field, (128, 255))?;
12965 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
12966
12967 let keys = unsafe { keys.deref_unchecked() };
12968
12969 if keys.len() > 128 {
12970 return Err(::fidl_next::DecodeError::VectorTooLong {
12971 size: keys.len() as u64,
12972 limit: 128,
12973 });
12974 }
12975
12976 Ok(())
12977 }
12978 }
12979
12980 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
12981 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
12982 }
12983
12984 impl ::fidl_next::Unconstrained for DictionaryKeysIteratorGetNextResponse<'static> {}
12985
12986 #[repr(transparent)]
12988 pub struct DictionaryRouterRouteResponse {
12989 pub(crate) raw: ::fidl_next::RawWireUnion,
12990 pub(crate) _phantom: ::core::marker::PhantomData<()>,
12991 }
12992
12993 impl Drop for DictionaryRouterRouteResponse {
12994 fn drop(&mut self) {
12995 match self.raw.ordinal() {
12996 1 => {
12997 let _ =
12998 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
12999 }
13000
13001 2 => {
13002 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13003 }
13004
13005 _ => unsafe { ::core::hint::unreachable_unchecked() },
13006 }
13007 }
13008 }
13009
13010 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
13011 type Decoded<'de> = DictionaryRouterRouteResponse;
13012
13013 #[inline]
13014 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13015 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13016 ::fidl_next::RawWireUnion::zero_padding(raw);
13017 }
13018 }
13019
13020 pub mod dictionary_router_route_response {
13021 pub enum Ref<'de> {
13022 Dictionary(&'de crate::wire::DictionaryRef),
13023
13024 Unavailable(&'de crate::wire::Unit),
13025 }
13026 }
13027
13028 impl DictionaryRouterRouteResponse {
13029 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
13030 match self.raw.ordinal() {
13031 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
13032 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
13033 }),
13034
13035 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
13036 self.raw.get().deref_unchecked::<crate::wire::Unit>()
13037 }),
13038
13039 _ => unsafe { ::core::hint::unreachable_unchecked() },
13040 }
13041 }
13042 }
13043
13044 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
13045 where
13046 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13047 ___D: ::fidl_next::fuchsia::HandleDecoder,
13048 {
13049 fn decode(
13050 mut slot: ::fidl_next::Slot<'_, Self>,
13051 decoder: &mut ___D,
13052 _: (),
13053 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13054 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13055 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13056 1 => {
13057 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
13058 raw,
13059 decoder,
13060 (),
13061 )?
13062 }
13063
13064 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13065 raw,
13066 decoder,
13067 (),
13068 )?,
13069
13070 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13071 }
13072
13073 Ok(())
13074 }
13075 }
13076
13077 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
13078 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13079 match self.raw.ordinal() {
13080 1 => unsafe {
13081 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
13082 },
13083 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13084 _ => unsafe { ::core::hint::unreachable_unchecked() },
13085 }
13086 }
13087 }
13088
13089 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
13090 type Natural = crate::natural::DictionaryRouterRouteResponse;
13091 }
13092
13093 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
13094
13095 #[repr(transparent)]
13097 pub struct DirConnectorRouterRouteResponse {
13098 pub(crate) raw: ::fidl_next::RawWireUnion,
13099 pub(crate) _phantom: ::core::marker::PhantomData<()>,
13100 }
13101
13102 impl Drop for DirConnectorRouterRouteResponse {
13103 fn drop(&mut self) {
13104 match self.raw.ordinal() {
13105 1 => {
13106 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
13107 }
13108
13109 2 => {
13110 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13111 }
13112
13113 _ => unsafe { ::core::hint::unreachable_unchecked() },
13114 }
13115 }
13116 }
13117
13118 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
13119 type Decoded<'de> = DirConnectorRouterRouteResponse;
13120
13121 #[inline]
13122 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13123 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13124 ::fidl_next::RawWireUnion::zero_padding(raw);
13125 }
13126 }
13127
13128 pub mod dir_connector_router_route_response {
13129 pub enum Ref<'de> {
13130 DirConnector(&'de crate::wire::DirConnector),
13131
13132 Unavailable(&'de crate::wire::Unit),
13133 }
13134 }
13135
13136 impl DirConnectorRouterRouteResponse {
13137 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
13138 match self.raw.ordinal() {
13139 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
13140 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
13141 }),
13142
13143 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
13144 self.raw.get().deref_unchecked::<crate::wire::Unit>()
13145 }),
13146
13147 _ => unsafe { ::core::hint::unreachable_unchecked() },
13148 }
13149 }
13150 }
13151
13152 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
13153 where
13154 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13155 ___D: ::fidl_next::fuchsia::HandleDecoder,
13156 {
13157 fn decode(
13158 mut slot: ::fidl_next::Slot<'_, Self>,
13159 decoder: &mut ___D,
13160 _: (),
13161 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13162 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13163 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13164 1 => {
13165 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
13166 raw,
13167 decoder,
13168 (),
13169 )?
13170 }
13171
13172 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13173 raw,
13174 decoder,
13175 (),
13176 )?,
13177
13178 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13179 }
13180
13181 Ok(())
13182 }
13183 }
13184
13185 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
13186 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13187 match self.raw.ordinal() {
13188 1 => unsafe {
13189 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
13190 },
13191 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13192 _ => unsafe { ::core::hint::unreachable_unchecked() },
13193 }
13194 }
13195 }
13196
13197 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
13198 type Natural = crate::natural::DirConnectorRouterRouteResponse;
13199 }
13200
13201 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
13202
13203 #[repr(transparent)]
13205 pub struct DirEntryRouterRouteResponse {
13206 pub(crate) raw: ::fidl_next::RawWireUnion,
13207 pub(crate) _phantom: ::core::marker::PhantomData<()>,
13208 }
13209
13210 impl Drop for DirEntryRouterRouteResponse {
13211 fn drop(&mut self) {
13212 match self.raw.ordinal() {
13213 1 => {
13214 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
13215 }
13216
13217 2 => {
13218 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13219 }
13220
13221 _ => unsafe { ::core::hint::unreachable_unchecked() },
13222 }
13223 }
13224 }
13225
13226 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
13227 type Decoded<'de> = DirEntryRouterRouteResponse;
13228
13229 #[inline]
13230 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13231 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13232 ::fidl_next::RawWireUnion::zero_padding(raw);
13233 }
13234 }
13235
13236 pub mod dir_entry_router_route_response {
13237 pub enum Ref<'de> {
13238 DirEntry(&'de crate::wire::DirEntry),
13239
13240 Unavailable(&'de crate::wire::Unit),
13241 }
13242 }
13243
13244 impl DirEntryRouterRouteResponse {
13245 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
13246 match self.raw.ordinal() {
13247 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
13248 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
13249 }),
13250
13251 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
13252 self.raw.get().deref_unchecked::<crate::wire::Unit>()
13253 }),
13254
13255 _ => unsafe { ::core::hint::unreachable_unchecked() },
13256 }
13257 }
13258 }
13259
13260 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
13261 where
13262 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13263 ___D: ::fidl_next::fuchsia::HandleDecoder,
13264 {
13265 fn decode(
13266 mut slot: ::fidl_next::Slot<'_, Self>,
13267 decoder: &mut ___D,
13268 _: (),
13269 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13270 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13271 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13272 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
13273 raw,
13274 decoder,
13275 (),
13276 )?,
13277
13278 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13279 raw,
13280 decoder,
13281 (),
13282 )?,
13283
13284 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13285 }
13286
13287 Ok(())
13288 }
13289 }
13290
13291 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
13292 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13293 match self.raw.ordinal() {
13294 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
13295 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13296 _ => unsafe { ::core::hint::unreachable_unchecked() },
13297 }
13298 }
13299 }
13300
13301 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
13302 type Natural = crate::natural::DirEntryRouterRouteResponse;
13303 }
13304
13305 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
13306
13307 #[derive(Debug)]
13309 #[repr(C)]
13310 pub struct DirReceiverReceiveRequest {
13311 pub channel: ::fidl_next::ServerEnd<
13312 ::fidl_next_fuchsia_io::Directory,
13313 ::fidl_next::fuchsia::WireChannel,
13314 >,
13315 }
13316
13317 static_assertions::const_assert_eq!(std::mem::size_of::<DirReceiverReceiveRequest>(), 4);
13318 static_assertions::const_assert_eq!(std::mem::align_of::<DirReceiverReceiveRequest>(), 4);
13319
13320 static_assertions::const_assert_eq!(
13321 std::mem::offset_of!(DirReceiverReceiveRequest, channel),
13322 0
13323 );
13324
13325 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest {
13326 type Decoded<'de> = DirReceiverReceiveRequest;
13327
13328 #[inline]
13329 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13330 ::fidl_next::munge! {
13331 let Self {
13332
13333 channel,
13334
13335 } = &mut *out_;
13336 }
13337
13338 ::fidl_next::Wire::zero_padding(channel);
13339 }
13340 }
13341
13342 unsafe impl<___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest
13343 where
13344 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13345 ___D: ::fidl_next::fuchsia::HandleDecoder,
13346 {
13347 fn decode(
13348 slot_: ::fidl_next::Slot<'_, Self>,
13349 decoder_: &mut ___D,
13350 _: (),
13351 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13352 ::fidl_next::munge! {
13353 let Self {
13354
13355 mut channel,
13356
13357 } = slot_;
13358 }
13359
13360 let _field = channel.as_mut();
13361
13362 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
13363
13364 Ok(())
13365 }
13366 }
13367
13368 impl ::fidl_next::IntoNatural for DirReceiverReceiveRequest {
13369 type Natural = crate::natural::DirReceiverReceiveRequest;
13370 }
13371
13372 impl ::fidl_next::Unconstrained for DirReceiverReceiveRequest {}
13373
13374 #[repr(transparent)]
13376 pub struct DirectoryRouterRouteResponse {
13377 pub(crate) raw: ::fidl_next::RawWireUnion,
13378 pub(crate) _phantom: ::core::marker::PhantomData<()>,
13379 }
13380
13381 impl Drop for DirectoryRouterRouteResponse {
13382 fn drop(&mut self) {
13383 match self.raw.ordinal() {
13384 1 => {
13385 let _ = unsafe {
13386 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
13387 ::fidl_next_fuchsia_io::Directory,
13388 ::fidl_next::fuchsia::WireChannel,
13389 >>()
13390 };
13391 }
13392
13393 2 => {
13394 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13395 }
13396
13397 _ => unsafe { ::core::hint::unreachable_unchecked() },
13398 }
13399 }
13400 }
13401
13402 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
13403 type Decoded<'de> = DirectoryRouterRouteResponse;
13404
13405 #[inline]
13406 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13407 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13408 ::fidl_next::RawWireUnion::zero_padding(raw);
13409 }
13410 }
13411
13412 pub mod directory_router_route_response {
13413 pub enum Ref<'de> {
13414 Directory(
13415 &'de ::fidl_next::ClientEnd<
13416 ::fidl_next_fuchsia_io::Directory,
13417 ::fidl_next::fuchsia::WireChannel,
13418 >,
13419 ),
13420
13421 Unavailable(&'de crate::wire::Unit),
13422 }
13423 }
13424
13425 impl DirectoryRouterRouteResponse {
13426 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
13427 match self.raw.ordinal() {
13428 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
13429 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
13430 ::fidl_next_fuchsia_io::Directory,
13431 ::fidl_next::fuchsia::WireChannel,
13432 >>()
13433 }),
13434
13435 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
13436 self.raw.get().deref_unchecked::<crate::wire::Unit>()
13437 }),
13438
13439 _ => unsafe { ::core::hint::unreachable_unchecked() },
13440 }
13441 }
13442 }
13443
13444 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
13445 where
13446 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13447 ___D: ::fidl_next::fuchsia::HandleDecoder,
13448 {
13449 fn decode(
13450 mut slot: ::fidl_next::Slot<'_, Self>,
13451 decoder: &mut ___D,
13452 _: (),
13453 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13454 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13455 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13456 1 => ::fidl_next::RawWireUnion::decode_as_static::<
13457 ___D,
13458 ::fidl_next::ClientEnd<
13459 ::fidl_next_fuchsia_io::Directory,
13460 ::fidl_next::fuchsia::WireChannel,
13461 >,
13462 >(raw, decoder, ())?,
13463
13464 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13465 raw,
13466 decoder,
13467 (),
13468 )?,
13469
13470 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13471 }
13472
13473 Ok(())
13474 }
13475 }
13476
13477 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
13478 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13479 match self.raw.ordinal() {
13480 1 => unsafe {
13481 self.raw
13482 .get()
13483 .deref_unchecked::<::fidl_next::ClientEnd<
13484 ::fidl_next_fuchsia_io::Directory,
13485 ::fidl_next::fuchsia::WireChannel,
13486 >>()
13487 .fmt(f)
13488 },
13489 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13490 _ => unsafe { ::core::hint::unreachable_unchecked() },
13491 }
13492 }
13493 }
13494
13495 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
13496 type Natural = crate::natural::DirectoryRouterRouteResponse;
13497 }
13498
13499 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
13500
13501 #[derive(Debug)]
13503 #[repr(C)]
13504 pub struct ProtocolPayload {
13505 pub channel: ::fidl_next::fuchsia::WireChannel,
13506 }
13507
13508 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
13509 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
13510
13511 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
13512
13513 unsafe impl ::fidl_next::Wire for ProtocolPayload {
13514 type Decoded<'de> = ProtocolPayload;
13515
13516 #[inline]
13517 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13518 ::fidl_next::munge! {
13519 let Self {
13520
13521 channel,
13522
13523 } = &mut *out_;
13524 }
13525
13526 ::fidl_next::Wire::zero_padding(channel);
13527 }
13528 }
13529
13530 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
13531 where
13532 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13533 ___D: ::fidl_next::fuchsia::HandleDecoder,
13534 {
13535 fn decode(
13536 slot_: ::fidl_next::Slot<'_, Self>,
13537 decoder_: &mut ___D,
13538 _: (),
13539 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13540 ::fidl_next::munge! {
13541 let Self {
13542
13543 mut channel,
13544
13545 } = slot_;
13546 }
13547
13548 let _field = channel.as_mut();
13549
13550 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
13551
13552 Ok(())
13553 }
13554 }
13555
13556 impl ::fidl_next::IntoNatural for ProtocolPayload {
13557 type Natural = crate::natural::ProtocolPayload;
13558 }
13559
13560 impl ::fidl_next::Unconstrained for ProtocolPayload {}
13561
13562 #[derive(Clone, Debug)]
13564 #[repr(C)]
13565 pub struct Unavailable {
13566 pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
13567 }
13568
13569 static_assertions::const_assert_eq!(std::mem::size_of::<Unavailable>(), 1);
13570 static_assertions::const_assert_eq!(std::mem::align_of::<Unavailable>(), 1);
13571
13572 unsafe impl ::fidl_next::Wire for Unavailable {
13573 type Decoded<'de> = Unavailable;
13574
13575 #[inline]
13576 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13577 ::fidl_next::munge! {
13578 let Self {
13579
13580 _empty,
13581
13582
13583 } = &mut *out_;
13584 }
13585 }
13586 }
13587
13588 unsafe impl<___D> ::fidl_next::Decode<___D> for Unavailable
13589 where
13590 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13591 {
13592 fn decode(
13593 slot_: ::fidl_next::Slot<'_, Self>,
13594 decoder_: &mut ___D,
13595 _: (),
13596 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13597 ::fidl_next::munge! {
13598 let Self {
13599
13600 mut _empty,
13601
13602
13603 } = slot_;
13604 }
13605
13606 if _empty.as_bytes() != &[0u8] {
13607 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
13608 }
13609
13610 Ok(())
13611 }
13612 }
13613
13614 impl ::fidl_next::IntoNatural for Unavailable {
13615 type Natural = crate::natural::Unavailable;
13616 }
13617
13618 impl ::fidl_next::Unconstrained for Unavailable {}
13619}
13620
13621pub mod wire_optional {
13622
13623 #[repr(transparent)]
13624 pub struct Data<'de> {
13625 pub(crate) raw: ::fidl_next::RawWireUnion,
13626 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13627 }
13628
13629 unsafe impl ::fidl_next::Wire for Data<'static> {
13630 type Decoded<'de> = Data<'de>;
13631
13632 #[inline]
13633 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13634 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13635 ::fidl_next::RawWireUnion::zero_padding(raw);
13636 }
13637 }
13638
13639 impl<'de> Data<'de> {
13640 pub fn is_some(&self) -> bool {
13641 self.raw.is_some()
13642 }
13643
13644 pub fn is_none(&self) -> bool {
13645 self.raw.is_none()
13646 }
13647
13648 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Data<'de>> {
13649 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13650 }
13651
13652 pub fn into_option(self) -> ::core::option::Option<crate::wire::Data<'de>> {
13653 if self.is_some() {
13654 Some(crate::wire::Data { raw: self.raw, _phantom: ::core::marker::PhantomData })
13655 } else {
13656 None
13657 }
13658 }
13659 }
13660
13661 unsafe impl<___D> ::fidl_next::Decode<___D> for Data<'static>
13662 where
13663 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13664 ___D: ::fidl_next::Decoder,
13665 {
13666 fn decode(
13667 mut slot: ::fidl_next::Slot<'_, Self>,
13668 decoder: &mut ___D,
13669 _: (),
13670 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13671 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13672 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13673 1 => ::fidl_next::RawWireUnion::decode_as::<
13674 ___D,
13675 ::fidl_next::WireVector<'static, u8>,
13676 >(raw, decoder, (8192, ()))?,
13677
13678 2 => {
13679 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
13680 raw, decoder, 8192,
13681 )?
13682 }
13683
13684 3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(
13685 raw,
13686 decoder,
13687 (),
13688 )?,
13689
13690 4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(
13691 raw,
13692 decoder,
13693 (),
13694 )?,
13695
13696 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13697 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
13698 }
13699
13700 Ok(())
13701 }
13702 }
13703
13704 impl<'de> ::core::fmt::Debug for Data<'de> {
13705 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13706 self.as_ref().fmt(f)
13707 }
13708 }
13709
13710 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
13711 type Natural = ::core::option::Option<crate::natural::Data>;
13712 }
13713
13714 impl ::fidl_next::Unconstrained for Data<'static> {}
13715
13716 #[repr(transparent)]
13717 pub struct Capability<'de> {
13718 pub(crate) raw: ::fidl_next::RawWireUnion,
13719 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13720 }
13721
13722 unsafe impl ::fidl_next::Wire for Capability<'static> {
13723 type Decoded<'de> = Capability<'de>;
13724
13725 #[inline]
13726 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13727 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13728 ::fidl_next::RawWireUnion::zero_padding(raw);
13729 }
13730 }
13731
13732 impl<'de> Capability<'de> {
13733 pub fn is_some(&self) -> bool {
13734 self.raw.is_some()
13735 }
13736
13737 pub fn is_none(&self) -> bool {
13738 self.raw.is_none()
13739 }
13740
13741 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
13742 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13743 }
13744
13745 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
13746 if self.is_some() {
13747 Some(crate::wire::Capability {
13748 raw: self.raw,
13749 _phantom: ::core::marker::PhantomData,
13750 })
13751 } else {
13752 None
13753 }
13754 }
13755 }
13756
13757 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
13758 where
13759 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13760 ___D: ::fidl_next::Decoder,
13761 ___D: ::fidl_next::fuchsia::HandleDecoder,
13762 {
13763 fn decode(
13764 mut slot: ::fidl_next::Slot<'_, Self>,
13765 decoder: &mut ___D,
13766 _: (),
13767 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13768 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13769 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13770 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
13771 raw,
13772 decoder,
13773 (),
13774 )?,
13775
13776 2 => {
13777 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
13778 raw,
13779 decoder,
13780 (),
13781 )?
13782 }
13783
13784 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
13785 raw,
13786 decoder,
13787 (),
13788 )?,
13789
13790 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
13791 raw,
13792 decoder,
13793 (),
13794 )?,
13795
13796 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
13797 raw,
13798 decoder,
13799 (),
13800 )?,
13801
13802 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
13803 raw,
13804 decoder,
13805 (),
13806 )?,
13807
13808 7 => ::fidl_next::RawWireUnion::decode_as::<
13809 ___D,
13810 ::fidl_next::ClientEnd<
13811 ::fidl_next_fuchsia_io::Directory,
13812 ::fidl_next::fuchsia::WireChannel,
13813 >,
13814 >(raw, decoder, ())?,
13815
13816 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
13817 raw,
13818 decoder,
13819 (),
13820 )?,
13821
13822 9 => ::fidl_next::RawWireUnion::decode_as::<
13823 ___D,
13824 ::fidl_next::ClientEnd<
13825 crate::ConnectorRouter,
13826 ::fidl_next::fuchsia::WireChannel,
13827 >,
13828 >(raw, decoder, ())?,
13829
13830 10 => ::fidl_next::RawWireUnion::decode_as::<
13831 ___D,
13832 ::fidl_next::ClientEnd<
13833 crate::DictionaryRouter,
13834 ::fidl_next::fuchsia::WireChannel,
13835 >,
13836 >(raw, decoder, ())?,
13837
13838 11 => ::fidl_next::RawWireUnion::decode_as::<
13839 ___D,
13840 ::fidl_next::ClientEnd<
13841 crate::DirEntryRouter,
13842 ::fidl_next::fuchsia::WireChannel,
13843 >,
13844 >(raw, decoder, ())?,
13845
13846 12 => ::fidl_next::RawWireUnion::decode_as::<
13847 ___D,
13848 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
13849 >(raw, decoder, ())?,
13850
13851 13 => ::fidl_next::RawWireUnion::decode_as::<
13852 ___D,
13853 ::fidl_next::ClientEnd<
13854 crate::DirConnectorRouter,
13855 ::fidl_next::fuchsia::WireChannel,
13856 >,
13857 >(raw, decoder, ())?,
13858
13859 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13860 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
13861 }
13862
13863 Ok(())
13864 }
13865 }
13866
13867 impl<'de> ::core::fmt::Debug for Capability<'de> {
13868 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13869 self.as_ref().fmt(f)
13870 }
13871 }
13872
13873 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
13874 type Natural = ::core::option::Option<crate::natural::Capability>;
13875 }
13876
13877 impl ::fidl_next::Unconstrained for Capability<'static> {}
13878
13879 #[repr(transparent)]
13880 pub struct ConnectorRouterRouteResponse {
13881 pub(crate) raw: ::fidl_next::RawWireUnion,
13882 pub(crate) _phantom: ::core::marker::PhantomData<()>,
13883 }
13884
13885 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
13886 type Decoded<'de> = ConnectorRouterRouteResponse;
13887
13888 #[inline]
13889 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13890 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13891 ::fidl_next::RawWireUnion::zero_padding(raw);
13892 }
13893 }
13894
13895 impl ConnectorRouterRouteResponse {
13896 pub fn is_some(&self) -> bool {
13897 self.raw.is_some()
13898 }
13899
13900 pub fn is_none(&self) -> bool {
13901 self.raw.is_none()
13902 }
13903
13904 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
13905 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13906 }
13907
13908 pub fn into_option(
13909 self,
13910 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
13911 if self.is_some() {
13912 Some(crate::wire::ConnectorRouterRouteResponse {
13913 raw: self.raw,
13914 _phantom: ::core::marker::PhantomData,
13915 })
13916 } else {
13917 None
13918 }
13919 }
13920 }
13921
13922 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
13923 where
13924 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13925 ___D: ::fidl_next::fuchsia::HandleDecoder,
13926 {
13927 fn decode(
13928 mut slot: ::fidl_next::Slot<'_, Self>,
13929 decoder: &mut ___D,
13930 _: (),
13931 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13932 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13933 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13934 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
13935 raw,
13936 decoder,
13937 (),
13938 )?,
13939
13940 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13941 raw,
13942 decoder,
13943 (),
13944 )?,
13945
13946 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13947 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13948 }
13949
13950 Ok(())
13951 }
13952 }
13953
13954 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
13955 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13956 self.as_ref().fmt(f)
13957 }
13958 }
13959
13960 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
13961 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
13962 }
13963
13964 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
13965
13966 #[repr(transparent)]
13967 pub struct DataRouterRouteResponse<'de> {
13968 pub(crate) raw: ::fidl_next::RawWireUnion,
13969 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13970 }
13971
13972 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
13973 type Decoded<'de> = DataRouterRouteResponse<'de>;
13974
13975 #[inline]
13976 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13977 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13978 ::fidl_next::RawWireUnion::zero_padding(raw);
13979 }
13980 }
13981
13982 impl<'de> DataRouterRouteResponse<'de> {
13983 pub fn is_some(&self) -> bool {
13984 self.raw.is_some()
13985 }
13986
13987 pub fn is_none(&self) -> bool {
13988 self.raw.is_none()
13989 }
13990
13991 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
13992 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13993 }
13994
13995 pub fn into_option(
13996 self,
13997 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
13998 if self.is_some() {
13999 Some(crate::wire::DataRouterRouteResponse {
14000 raw: self.raw,
14001 _phantom: ::core::marker::PhantomData,
14002 })
14003 } else {
14004 None
14005 }
14006 }
14007 }
14008
14009 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
14010 where
14011 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14012 ___D: ::fidl_next::Decoder,
14013 ___D: ::fidl_next::fuchsia::HandleDecoder,
14014 {
14015 fn decode(
14016 mut slot: ::fidl_next::Slot<'_, Self>,
14017 decoder: &mut ___D,
14018 _: (),
14019 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14020 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14021 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14022 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
14023 raw,
14024 decoder,
14025 (),
14026 )?,
14027
14028 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
14029 raw,
14030 decoder,
14031 (),
14032 )?,
14033
14034 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14035 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
14036 }
14037
14038 Ok(())
14039 }
14040 }
14041
14042 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
14043 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14044 self.as_ref().fmt(f)
14045 }
14046 }
14047
14048 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
14049 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
14050 }
14051
14052 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
14053
14054 #[repr(transparent)]
14055 pub struct DictionaryRouterRouteResponse {
14056 pub(crate) raw: ::fidl_next::RawWireUnion,
14057 pub(crate) _phantom: ::core::marker::PhantomData<()>,
14058 }
14059
14060 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
14061 type Decoded<'de> = DictionaryRouterRouteResponse;
14062
14063 #[inline]
14064 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14065 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14066 ::fidl_next::RawWireUnion::zero_padding(raw);
14067 }
14068 }
14069
14070 impl DictionaryRouterRouteResponse {
14071 pub fn is_some(&self) -> bool {
14072 self.raw.is_some()
14073 }
14074
14075 pub fn is_none(&self) -> bool {
14076 self.raw.is_none()
14077 }
14078
14079 pub fn as_ref(
14080 &self,
14081 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
14082 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14083 }
14084
14085 pub fn into_option(
14086 self,
14087 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
14088 if self.is_some() {
14089 Some(crate::wire::DictionaryRouterRouteResponse {
14090 raw: self.raw,
14091 _phantom: ::core::marker::PhantomData,
14092 })
14093 } else {
14094 None
14095 }
14096 }
14097 }
14098
14099 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
14100 where
14101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14102 ___D: ::fidl_next::fuchsia::HandleDecoder,
14103 {
14104 fn decode(
14105 mut slot: ::fidl_next::Slot<'_, Self>,
14106 decoder: &mut ___D,
14107 _: (),
14108 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14109 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14110 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14111 1 => {
14112 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
14113 raw,
14114 decoder,
14115 (),
14116 )?
14117 }
14118
14119 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14120 raw,
14121 decoder,
14122 (),
14123 )?,
14124
14125 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14126 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14127 }
14128
14129 Ok(())
14130 }
14131 }
14132
14133 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
14134 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14135 self.as_ref().fmt(f)
14136 }
14137 }
14138
14139 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
14140 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
14141 }
14142
14143 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
14144
14145 #[repr(transparent)]
14146 pub struct DirConnectorRouterRouteResponse {
14147 pub(crate) raw: ::fidl_next::RawWireUnion,
14148 pub(crate) _phantom: ::core::marker::PhantomData<()>,
14149 }
14150
14151 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
14152 type Decoded<'de> = DirConnectorRouterRouteResponse;
14153
14154 #[inline]
14155 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14156 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14157 ::fidl_next::RawWireUnion::zero_padding(raw);
14158 }
14159 }
14160
14161 impl DirConnectorRouterRouteResponse {
14162 pub fn is_some(&self) -> bool {
14163 self.raw.is_some()
14164 }
14165
14166 pub fn is_none(&self) -> bool {
14167 self.raw.is_none()
14168 }
14169
14170 pub fn as_ref(
14171 &self,
14172 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
14173 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14174 }
14175
14176 pub fn into_option(
14177 self,
14178 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
14179 if self.is_some() {
14180 Some(crate::wire::DirConnectorRouterRouteResponse {
14181 raw: self.raw,
14182 _phantom: ::core::marker::PhantomData,
14183 })
14184 } else {
14185 None
14186 }
14187 }
14188 }
14189
14190 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
14191 where
14192 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14193 ___D: ::fidl_next::fuchsia::HandleDecoder,
14194 {
14195 fn decode(
14196 mut slot: ::fidl_next::Slot<'_, Self>,
14197 decoder: &mut ___D,
14198 _: (),
14199 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14200 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14201 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14202 1 => {
14203 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
14204 raw,
14205 decoder,
14206 (),
14207 )?
14208 }
14209
14210 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14211 raw,
14212 decoder,
14213 (),
14214 )?,
14215
14216 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14217 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14218 }
14219
14220 Ok(())
14221 }
14222 }
14223
14224 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
14225 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14226 self.as_ref().fmt(f)
14227 }
14228 }
14229
14230 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
14231 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
14232 }
14233
14234 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
14235
14236 #[repr(transparent)]
14237 pub struct DirEntryRouterRouteResponse {
14238 pub(crate) raw: ::fidl_next::RawWireUnion,
14239 pub(crate) _phantom: ::core::marker::PhantomData<()>,
14240 }
14241
14242 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
14243 type Decoded<'de> = DirEntryRouterRouteResponse;
14244
14245 #[inline]
14246 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14247 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14248 ::fidl_next::RawWireUnion::zero_padding(raw);
14249 }
14250 }
14251
14252 impl DirEntryRouterRouteResponse {
14253 pub fn is_some(&self) -> bool {
14254 self.raw.is_some()
14255 }
14256
14257 pub fn is_none(&self) -> bool {
14258 self.raw.is_none()
14259 }
14260
14261 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
14262 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14263 }
14264
14265 pub fn into_option(
14266 self,
14267 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
14268 if self.is_some() {
14269 Some(crate::wire::DirEntryRouterRouteResponse {
14270 raw: self.raw,
14271 _phantom: ::core::marker::PhantomData,
14272 })
14273 } else {
14274 None
14275 }
14276 }
14277 }
14278
14279 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
14280 where
14281 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14282 ___D: ::fidl_next::fuchsia::HandleDecoder,
14283 {
14284 fn decode(
14285 mut slot: ::fidl_next::Slot<'_, Self>,
14286 decoder: &mut ___D,
14287 _: (),
14288 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14289 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14290 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14291 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
14292 raw,
14293 decoder,
14294 (),
14295 )?,
14296
14297 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14298 raw,
14299 decoder,
14300 (),
14301 )?,
14302
14303 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14304 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14305 }
14306
14307 Ok(())
14308 }
14309 }
14310
14311 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
14312 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14313 self.as_ref().fmt(f)
14314 }
14315 }
14316
14317 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
14318 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
14319 }
14320
14321 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
14322
14323 #[repr(transparent)]
14324 pub struct DirectoryRouterRouteResponse {
14325 pub(crate) raw: ::fidl_next::RawWireUnion,
14326 pub(crate) _phantom: ::core::marker::PhantomData<()>,
14327 }
14328
14329 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
14330 type Decoded<'de> = DirectoryRouterRouteResponse;
14331
14332 #[inline]
14333 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14334 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14335 ::fidl_next::RawWireUnion::zero_padding(raw);
14336 }
14337 }
14338
14339 impl DirectoryRouterRouteResponse {
14340 pub fn is_some(&self) -> bool {
14341 self.raw.is_some()
14342 }
14343
14344 pub fn is_none(&self) -> bool {
14345 self.raw.is_none()
14346 }
14347
14348 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
14349 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14350 }
14351
14352 pub fn into_option(
14353 self,
14354 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
14355 if self.is_some() {
14356 Some(crate::wire::DirectoryRouterRouteResponse {
14357 raw: self.raw,
14358 _phantom: ::core::marker::PhantomData,
14359 })
14360 } else {
14361 None
14362 }
14363 }
14364 }
14365
14366 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
14367 where
14368 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14369 ___D: ::fidl_next::fuchsia::HandleDecoder,
14370 {
14371 fn decode(
14372 mut slot: ::fidl_next::Slot<'_, Self>,
14373 decoder: &mut ___D,
14374 _: (),
14375 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14376 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14377 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14378 1 => ::fidl_next::RawWireUnion::decode_as_static::<
14379 ___D,
14380 ::fidl_next::ClientEnd<
14381 ::fidl_next_fuchsia_io::Directory,
14382 ::fidl_next::fuchsia::WireChannel,
14383 >,
14384 >(raw, decoder, ())?,
14385
14386 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14387 raw,
14388 decoder,
14389 (),
14390 )?,
14391
14392 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14393 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14394 }
14395
14396 Ok(())
14397 }
14398 }
14399
14400 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
14401 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14402 self.as_ref().fmt(f)
14403 }
14404 }
14405
14406 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
14407 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
14408 }
14409
14410 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
14411}
14412
14413pub mod generic {
14414
14415 pub struct Unit {}
14416
14417 impl ::fidl_next::Encodable for Unit {
14418 type Encoded = crate::wire::Unit;
14419 }
14420
14421 unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
14422 where
14423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14424 {
14425 #[inline]
14426 fn encode(
14427 self,
14428 encoder_: &mut ___E,
14429 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14430 _: (),
14431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14432 ::fidl_next::munge! {
14433 let Self::Encoded {
14434
14435 _empty,
14436
14437
14438 } = out_;
14439 }
14440
14441 Ok(())
14442 }
14443 }
14444
14445 pub struct DictionaryRef<T0> {
14446 pub token: T0,
14447 }
14448
14449 impl<T0> ::fidl_next::Encodable for DictionaryRef<T0>
14450 where
14451 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14452 {
14453 type Encoded = crate::wire::DictionaryRef;
14454 }
14455
14456 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryRef<T0>
14457 where
14458 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14459 ___E: ::fidl_next::fuchsia::HandleEncoder,
14460 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14461 {
14462 #[inline]
14463 fn encode(
14464 self,
14465 encoder_: &mut ___E,
14466 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14467 _: (),
14468 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14469 ::fidl_next::munge! {
14470 let Self::Encoded {
14471
14472 token,
14473
14474 } = out_;
14475 }
14476
14477 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14478
14479 Ok(())
14480 }
14481 }
14482
14483 pub struct Connector<T0> {
14484 pub token: T0,
14485 }
14486
14487 impl<T0> ::fidl_next::Encodable for Connector<T0>
14488 where
14489 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14490 {
14491 type Encoded = crate::wire::Connector;
14492 }
14493
14494 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Connector<T0>
14495 where
14496 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14497 ___E: ::fidl_next::fuchsia::HandleEncoder,
14498 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14499 {
14500 #[inline]
14501 fn encode(
14502 self,
14503 encoder_: &mut ___E,
14504 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14505 _: (),
14506 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14507 ::fidl_next::munge! {
14508 let Self::Encoded {
14509
14510 token,
14511
14512 } = out_;
14513 }
14514
14515 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14516
14517 Ok(())
14518 }
14519 }
14520
14521 pub struct DirConnector<T0> {
14522 pub token: T0,
14523 }
14524
14525 impl<T0> ::fidl_next::Encodable for DirConnector<T0>
14526 where
14527 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14528 {
14529 type Encoded = crate::wire::DirConnector;
14530 }
14531
14532 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirConnector<T0>
14533 where
14534 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14535 ___E: ::fidl_next::fuchsia::HandleEncoder,
14536 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14537 {
14538 #[inline]
14539 fn encode(
14540 self,
14541 encoder_: &mut ___E,
14542 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14543 _: (),
14544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14545 ::fidl_next::munge! {
14546 let Self::Encoded {
14547
14548 token,
14549
14550 } = out_;
14551 }
14552
14553 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14554
14555 Ok(())
14556 }
14557 }
14558
14559 pub struct DirEntry<T0> {
14560 pub token: T0,
14561 }
14562
14563 impl<T0> ::fidl_next::Encodable for DirEntry<T0>
14564 where
14565 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14566 {
14567 type Encoded = crate::wire::DirEntry;
14568 }
14569
14570 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirEntry<T0>
14571 where
14572 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14573 ___E: ::fidl_next::fuchsia::HandleEncoder,
14574 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14575 {
14576 #[inline]
14577 fn encode(
14578 self,
14579 encoder_: &mut ___E,
14580 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14581 _: (),
14582 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14583 ::fidl_next::munge! {
14584 let Self::Encoded {
14585
14586 token,
14587
14588 } = out_;
14589 }
14590
14591 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14592
14593 Ok(())
14594 }
14595 }
14596
14597 pub struct CapabilityStoreDuplicateRequest<T0, T1> {
14598 pub id: T0,
14599
14600 pub dest_id: T1,
14601 }
14602
14603 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDuplicateRequest<T0, T1>
14604 where
14605 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14606 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14607 {
14608 type Encoded = crate::wire::CapabilityStoreDuplicateRequest;
14609 }
14610
14611 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest<T0, T1>
14612 where
14613 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14614 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14615 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14616 {
14617 #[inline]
14618 fn encode(
14619 self,
14620 encoder_: &mut ___E,
14621 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14622 _: (),
14623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14624 ::fidl_next::munge! {
14625 let Self::Encoded {
14626
14627 id,
14628 dest_id,
14629
14630 } = out_;
14631 }
14632
14633 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14634
14635 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
14636
14637 Ok(())
14638 }
14639 }
14640
14641 pub struct CapabilityStoreDropRequest<T0> {
14642 pub id: T0,
14643 }
14644
14645 impl<T0> ::fidl_next::Encodable for CapabilityStoreDropRequest<T0>
14646 where
14647 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14648 {
14649 type Encoded = crate::wire::CapabilityStoreDropRequest;
14650 }
14651
14652 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest<T0>
14653 where
14654 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14655 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14656 {
14657 #[inline]
14658 fn encode(
14659 self,
14660 encoder_: &mut ___E,
14661 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14662 _: (),
14663 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14664 ::fidl_next::munge! {
14665 let Self::Encoded {
14666
14667 id,
14668
14669 } = out_;
14670 }
14671
14672 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14673
14674 Ok(())
14675 }
14676 }
14677
14678 pub struct CapabilityStoreExportRequest<T0> {
14679 pub id: T0,
14680 }
14681
14682 impl<T0> ::fidl_next::Encodable for CapabilityStoreExportRequest<T0>
14683 where
14684 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14685 {
14686 type Encoded = crate::wire::CapabilityStoreExportRequest;
14687 }
14688
14689 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest<T0>
14690 where
14691 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14692 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14693 {
14694 #[inline]
14695 fn encode(
14696 self,
14697 encoder_: &mut ___E,
14698 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14699 _: (),
14700 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14701 ::fidl_next::munge! {
14702 let Self::Encoded {
14703
14704 id,
14705
14706 } = out_;
14707 }
14708
14709 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14710
14711 Ok(())
14712 }
14713 }
14714
14715 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
14716 pub id: T0,
14717
14718 pub receiver: T1,
14719 }
14720
14721 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest<T0, T1>
14722 where
14723 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14724 T1: ::fidl_next::Encodable<
14725 Encoded = ::fidl_next::ClientEnd<
14726 crate::Receiver,
14727 ::fidl_next::fuchsia::WireChannel,
14728 >,
14729 >,
14730 {
14731 type Encoded = crate::wire::CapabilityStoreConnectorCreateRequest;
14732 }
14733
14734 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14735 for CapabilityStoreConnectorCreateRequest<T0, T1>
14736 where
14737 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14738 ___E: ::fidl_next::fuchsia::HandleEncoder,
14739 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14740 T1: ::fidl_next::Encode<
14741 ___E,
14742 Encoded = ::fidl_next::ClientEnd<
14743 crate::Receiver,
14744 ::fidl_next::fuchsia::WireChannel,
14745 >,
14746 >,
14747 {
14748 #[inline]
14749 fn encode(
14750 self,
14751 encoder_: &mut ___E,
14752 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14753 _: (),
14754 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14755 ::fidl_next::munge! {
14756 let Self::Encoded {
14757
14758 id,
14759 receiver,
14760
14761 } = out_;
14762 }
14763
14764 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14765
14766 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
14767
14768 Ok(())
14769 }
14770 }
14771
14772 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
14773 pub id: T0,
14774
14775 pub server_end: T1,
14776 }
14777
14778 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest<T0, T1>
14779 where
14780 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14781 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14782 {
14783 type Encoded = crate::wire::CapabilityStoreConnectorOpenRequest;
14784 }
14785
14786 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest<T0, T1>
14787 where
14788 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14789 ___E: ::fidl_next::fuchsia::HandleEncoder,
14790 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14791 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14792 {
14793 #[inline]
14794 fn encode(
14795 self,
14796 encoder_: &mut ___E,
14797 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14798 _: (),
14799 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14800 ::fidl_next::munge! {
14801 let Self::Encoded {
14802
14803 id,
14804 server_end,
14805
14806 } = out_;
14807 }
14808
14809 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14810
14811 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
14812
14813 Ok(())
14814 }
14815 }
14816
14817 pub struct CapabilityStoreDictionaryCreateRequest<T0> {
14818 pub id: T0,
14819 }
14820
14821 impl<T0> ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest<T0>
14822 where
14823 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14824 {
14825 type Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest;
14826 }
14827
14828 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest<T0>
14829 where
14830 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14831 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14832 {
14833 #[inline]
14834 fn encode(
14835 self,
14836 encoder_: &mut ___E,
14837 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14838 _: (),
14839 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14840 ::fidl_next::munge! {
14841 let Self::Encoded {
14842
14843 id,
14844
14845 } = out_;
14846 }
14847
14848 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14849
14850 Ok(())
14851 }
14852 }
14853
14854 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
14855 pub id: T0,
14856
14857 pub client_end: T1,
14858 }
14859
14860 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
14861 where
14862 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14863 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14864 {
14865 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
14866 }
14867
14868 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14869 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
14870 where
14871 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14872 ___E: ::fidl_next::fuchsia::HandleEncoder,
14873 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14874 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14875 {
14876 #[inline]
14877 fn encode(
14878 self,
14879 encoder_: &mut ___E,
14880 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14881 _: (),
14882 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14883 ::fidl_next::munge! {
14884 let Self::Encoded {
14885
14886 id,
14887 client_end,
14888
14889 } = out_;
14890 }
14891
14892 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14893
14894 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
14895
14896 Ok(())
14897 }
14898 }
14899
14900 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
14901 pub id: T0,
14902
14903 pub server_end: T1,
14904 }
14905
14906 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
14907 where
14908 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14909 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14910 {
14911 type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
14912 }
14913
14914 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14915 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
14916 where
14917 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14918 ___E: ::fidl_next::fuchsia::HandleEncoder,
14919 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14920 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14921 {
14922 #[inline]
14923 fn encode(
14924 self,
14925 encoder_: &mut ___E,
14926 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14927 _: (),
14928 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14929 ::fidl_next::munge! {
14930 let Self::Encoded {
14931
14932 id,
14933 server_end,
14934
14935 } = out_;
14936 }
14937
14938 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14939
14940 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
14941
14942 Ok(())
14943 }
14944 }
14945
14946 pub struct DictionaryItem<T0, T1> {
14947 pub key: T0,
14948
14949 pub value: T1,
14950 }
14951
14952 impl<T0, T1> ::fidl_next::Encodable for DictionaryItem<T0, T1>
14953 where
14954 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
14955 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14956 {
14957 type Encoded = crate::wire::DictionaryItem<'static>;
14958 }
14959
14960 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryItem<T0, T1>
14961 where
14962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14963 ___E: ::fidl_next::Encoder,
14964 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
14965 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14966 {
14967 #[inline]
14968 fn encode(
14969 self,
14970 encoder_: &mut ___E,
14971 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14972 _: (),
14973 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14974 ::fidl_next::munge! {
14975 let Self::Encoded {
14976
14977 key,
14978 value,
14979
14980 } = out_;
14981 }
14982
14983 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
14984
14985 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
14986
14987 Ok(())
14988 }
14989 }
14990
14991 pub struct CapabilityStoreDictionaryInsertRequest<T0, T1> {
14992 pub id: T0,
14993
14994 pub item: T1,
14995 }
14996
14997 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest<T0, T1>
14998 where
14999 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15000 T1: ::fidl_next::Encodable<Encoded = crate::wire::DictionaryItem<'static>>,
15001 {
15002 type Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
15003 }
15004
15005 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15006 for CapabilityStoreDictionaryInsertRequest<T0, T1>
15007 where
15008 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15009 ___E: ::fidl_next::Encoder,
15010 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15011 T1: ::fidl_next::Encode<___E, Encoded = crate::wire::DictionaryItem<'static>>,
15012 {
15013 #[inline]
15014 fn encode(
15015 self,
15016 encoder_: &mut ___E,
15017 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15018 _: (),
15019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15020 ::fidl_next::munge! {
15021 let Self::Encoded {
15022
15023 id,
15024 item,
15025
15026 } = out_;
15027 }
15028
15029 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15030
15031 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
15032
15033 Ok(())
15034 }
15035 }
15036
15037 pub struct CapabilityStoreDictionaryGetRequest<T0, T1, T2> {
15038 pub id: T0,
15039
15040 pub key: T1,
15041
15042 pub dest_id: T2,
15043 }
15044
15045 impl<T0, T1, T2> ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
15046 where
15047 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15048 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15049 T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15050 {
15051 type Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
15052 }
15053
15054 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E>
15055 for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
15056 where
15057 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15058 ___E: ::fidl_next::Encoder,
15059 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15060 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15061 T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15062 {
15063 #[inline]
15064 fn encode(
15065 self,
15066 encoder_: &mut ___E,
15067 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15068 _: (),
15069 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15070 ::fidl_next::munge! {
15071 let Self::Encoded {
15072
15073 id,
15074 key,
15075 dest_id,
15076
15077 } = out_;
15078 }
15079
15080 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15081
15082 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15083
15084 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15085
15086 Ok(())
15087 }
15088 }
15089
15090 pub struct WrappedCapabilityId<T0> {
15091 pub id: T0,
15092 }
15093
15094 impl<T0> ::fidl_next::Encodable for WrappedCapabilityId<T0>
15095 where
15096 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15097 {
15098 type Encoded = crate::wire::WrappedCapabilityId;
15099 }
15100
15101 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for WrappedCapabilityId<T0>
15102 where
15103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15104 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15105 {
15106 #[inline]
15107 fn encode(
15108 self,
15109 encoder_: &mut ___E,
15110 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15111 _: (),
15112 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15113 ::fidl_next::munge! {
15114 let Self::Encoded {
15115
15116 id,
15117
15118 } = out_;
15119 }
15120
15121 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15122
15123 Ok(())
15124 }
15125 }
15126
15127 pub struct CapabilityStoreDictionaryRemoveRequest<T0, T1, T2> {
15128 pub id: T0,
15129
15130 pub key: T1,
15131
15132 pub dest_id: T2,
15133 }
15134
15135 impl<T0, T1, T2> ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
15136 where
15137 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15138 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15139 T2: ::fidl_next::Encodable<
15140 Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15141 >,
15142 {
15143 type Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
15144 }
15145
15146 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E>
15147 for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
15148 where
15149 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15150 ___E: ::fidl_next::Encoder,
15151 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15152 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15153 T2: ::fidl_next::Encode<
15154 ___E,
15155 Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15156 >,
15157 {
15158 #[inline]
15159 fn encode(
15160 self,
15161 encoder_: &mut ___E,
15162 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15163 _: (),
15164 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15165 ::fidl_next::munge! {
15166 let Self::Encoded {
15167
15168 id,
15169 key,
15170 dest_id,
15171
15172 } = out_;
15173 }
15174
15175 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15176
15177 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15178
15179 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15180
15181 Ok(())
15182 }
15183 }
15184
15185 pub struct CapabilityStoreDictionaryCopyRequest<T0, T1> {
15186 pub id: T0,
15187
15188 pub dest_id: T1,
15189 }
15190
15191 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest<T0, T1>
15192 where
15193 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15194 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15195 {
15196 type Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest;
15197 }
15198
15199 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest<T0, T1>
15200 where
15201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15202 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15203 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15204 {
15205 #[inline]
15206 fn encode(
15207 self,
15208 encoder_: &mut ___E,
15209 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15210 _: (),
15211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15212 ::fidl_next::munge! {
15213 let Self::Encoded {
15214
15215 id,
15216 dest_id,
15217
15218 } = out_;
15219 }
15220
15221 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15222
15223 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15224
15225 Ok(())
15226 }
15227 }
15228
15229 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
15230 pub id: T0,
15231
15232 pub iterator: T1,
15233 }
15234
15235 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest<T0, T1>
15236 where
15237 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15238 T1: ::fidl_next::Encodable<
15239 Encoded = ::fidl_next::ServerEnd<
15240 crate::DictionaryKeysIterator,
15241 ::fidl_next::fuchsia::WireChannel,
15242 >,
15243 >,
15244 {
15245 type Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest;
15246 }
15247
15248 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest<T0, T1>
15249 where
15250 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15251 ___E: ::fidl_next::fuchsia::HandleEncoder,
15252 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15253 T1: ::fidl_next::Encode<
15254 ___E,
15255 Encoded = ::fidl_next::ServerEnd<
15256 crate::DictionaryKeysIterator,
15257 ::fidl_next::fuchsia::WireChannel,
15258 >,
15259 >,
15260 {
15261 #[inline]
15262 fn encode(
15263 self,
15264 encoder_: &mut ___E,
15265 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15266 _: (),
15267 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15268 ::fidl_next::munge! {
15269 let Self::Encoded {
15270
15271 id,
15272 iterator,
15273
15274 } = out_;
15275 }
15276
15277 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15278
15279 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15280
15281 Ok(())
15282 }
15283 }
15284
15285 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
15286 pub id: T0,
15287
15288 pub iterator: T1,
15289 }
15290
15291 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
15292 where
15293 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15294 T1: ::fidl_next::Encodable<
15295 Encoded = ::fidl_next::ServerEnd<
15296 crate::DictionaryEnumerateIterator,
15297 ::fidl_next::fuchsia::WireChannel,
15298 >,
15299 >,
15300 {
15301 type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
15302 }
15303
15304 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15305 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
15306 where
15307 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15308 ___E: ::fidl_next::fuchsia::HandleEncoder,
15309 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15310 T1: ::fidl_next::Encode<
15311 ___E,
15312 Encoded = ::fidl_next::ServerEnd<
15313 crate::DictionaryEnumerateIterator,
15314 ::fidl_next::fuchsia::WireChannel,
15315 >,
15316 >,
15317 {
15318 #[inline]
15319 fn encode(
15320 self,
15321 encoder_: &mut ___E,
15322 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15323 _: (),
15324 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15325 ::fidl_next::munge! {
15326 let Self::Encoded {
15327
15328 id,
15329 iterator,
15330
15331 } = out_;
15332 }
15333
15334 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15335
15336 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15337
15338 Ok(())
15339 }
15340 }
15341
15342 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
15343 pub id: T0,
15344
15345 pub iterator: T1,
15346 }
15347
15348 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest<T0, T1>
15349 where
15350 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15351 T1: ::fidl_next::Encodable<
15352 Encoded = ::fidl_next::ServerEnd<
15353 crate::DictionaryDrainIterator,
15354 ::fidl_next::fuchsia::WireOptionalChannel,
15355 >,
15356 >,
15357 {
15358 type Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest;
15359 }
15360
15361 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15362 for CapabilityStoreDictionaryDrainRequest<T0, T1>
15363 where
15364 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15365 ___E: ::fidl_next::fuchsia::HandleEncoder,
15366 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15367 T1: ::fidl_next::Encode<
15368 ___E,
15369 Encoded = ::fidl_next::ServerEnd<
15370 crate::DictionaryDrainIterator,
15371 ::fidl_next::fuchsia::WireOptionalChannel,
15372 >,
15373 >,
15374 {
15375 #[inline]
15376 fn encode(
15377 self,
15378 encoder_: &mut ___E,
15379 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15380 _: (),
15381 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15382 ::fidl_next::munge! {
15383 let Self::Encoded {
15384
15385 id,
15386 iterator,
15387
15388 } = out_;
15389 }
15390
15391 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15392
15393 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15394
15395 Ok(())
15396 }
15397 }
15398
15399 pub struct CapabilityStoreExportResponse<T0> {
15400 pub capability: T0,
15401 }
15402
15403 impl<T0> ::fidl_next::Encodable for CapabilityStoreExportResponse<T0>
15404 where
15405 T0: ::fidl_next::Encodable<Encoded = crate::wire::Capability<'static>>,
15406 {
15407 type Encoded = crate::wire::CapabilityStoreExportResponse<'static>;
15408 }
15409
15410 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse<T0>
15411 where
15412 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15413 ___E: ::fidl_next::Encoder,
15414 ___E: ::fidl_next::fuchsia::HandleEncoder,
15415 T0: ::fidl_next::Encode<___E, Encoded = crate::wire::Capability<'static>>,
15416 {
15417 #[inline]
15418 fn encode(
15419 self,
15420 encoder_: &mut ___E,
15421 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15422 _: (),
15423 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15424 ::fidl_next::munge! {
15425 let Self::Encoded {
15426
15427 capability,
15428
15429 } = out_;
15430 }
15431
15432 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
15433
15434 Ok(())
15435 }
15436 }
15437
15438 pub struct CapabilityStoreImportRequest<T0, T1> {
15439 pub id: T0,
15440
15441 pub capability: T1,
15442 }
15443
15444 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreImportRequest<T0, T1>
15445 where
15446 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15447 T1: ::fidl_next::Encodable<Encoded = crate::wire::Capability<'static>>,
15448 {
15449 type Encoded = crate::wire::CapabilityStoreImportRequest<'static>;
15450 }
15451
15452 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest<T0, T1>
15453 where
15454 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15455 ___E: ::fidl_next::Encoder,
15456 ___E: ::fidl_next::fuchsia::HandleEncoder,
15457 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15458 T1: ::fidl_next::Encode<___E, Encoded = crate::wire::Capability<'static>>,
15459 {
15460 #[inline]
15461 fn encode(
15462 self,
15463 encoder_: &mut ___E,
15464 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15465 _: (),
15466 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15467 ::fidl_next::munge! {
15468 let Self::Encoded {
15469
15470 id,
15471 capability,
15472
15473 } = out_;
15474 }
15475
15476 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15477
15478 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
15479
15480 Ok(())
15481 }
15482 }
15483
15484 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
15485 pub id: T0,
15486
15487 pub receiver: T1,
15488 }
15489
15490 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest<T0, T1>
15491 where
15492 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15493 T1: ::fidl_next::Encodable<
15494 Encoded = ::fidl_next::ClientEnd<
15495 crate::DirReceiver,
15496 ::fidl_next::fuchsia::WireChannel,
15497 >,
15498 >,
15499 {
15500 type Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest;
15501 }
15502
15503 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15504 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
15505 where
15506 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15507 ___E: ::fidl_next::fuchsia::HandleEncoder,
15508 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15509 T1: ::fidl_next::Encode<
15510 ___E,
15511 Encoded = ::fidl_next::ClientEnd<
15512 crate::DirReceiver,
15513 ::fidl_next::fuchsia::WireChannel,
15514 >,
15515 >,
15516 {
15517 #[inline]
15518 fn encode(
15519 self,
15520 encoder_: &mut ___E,
15521 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15522 _: (),
15523 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15524 ::fidl_next::munge! {
15525 let Self::Encoded {
15526
15527 id,
15528 receiver,
15529
15530 } = out_;
15531 }
15532
15533 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15534
15535 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
15536
15537 Ok(())
15538 }
15539 }
15540
15541 pub struct CapabilityStoreDirConnectorOpenRequest<T0, T1> {
15542 pub id: T0,
15543
15544 pub server_end: T1,
15545 }
15546
15547 impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest<T0, T1>
15548 where
15549 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15550 T1: ::fidl_next::Encodable<
15551 Encoded = ::fidl_next::ServerEnd<
15552 ::fidl_next_fuchsia_io::Directory,
15553 ::fidl_next::fuchsia::WireChannel,
15554 >,
15555 >,
15556 {
15557 type Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest;
15558 }
15559
15560 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15561 for CapabilityStoreDirConnectorOpenRequest<T0, T1>
15562 where
15563 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15564 ___E: ::fidl_next::fuchsia::HandleEncoder,
15565 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15566 T1: ::fidl_next::Encode<
15567 ___E,
15568 Encoded = ::fidl_next::ServerEnd<
15569 ::fidl_next_fuchsia_io::Directory,
15570 ::fidl_next::fuchsia::WireChannel,
15571 >,
15572 >,
15573 {
15574 #[inline]
15575 fn encode(
15576 self,
15577 encoder_: &mut ___E,
15578 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15579 _: (),
15580 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15581 ::fidl_next::munge! {
15582 let Self::Encoded {
15583
15584 id,
15585 server_end,
15586
15587 } = out_;
15588 }
15589
15590 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15591
15592 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
15593
15594 Ok(())
15595 }
15596 }
15597
15598 pub struct InstanceToken<T0> {
15599 pub token: T0,
15600 }
15601
15602 impl<T0> ::fidl_next::Encodable for InstanceToken<T0>
15603 where
15604 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
15605 {
15606 type Encoded = crate::wire::InstanceToken;
15607 }
15608
15609 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for InstanceToken<T0>
15610 where
15611 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15612 ___E: ::fidl_next::fuchsia::HandleEncoder,
15613 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
15614 {
15615 #[inline]
15616 fn encode(
15617 self,
15618 encoder_: &mut ___E,
15619 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15620 _: (),
15621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15622 ::fidl_next::munge! {
15623 let Self::Encoded {
15624
15625 token,
15626
15627 } = out_;
15628 }
15629
15630 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
15631
15632 Ok(())
15633 }
15634 }
15635
15636 pub struct DictionaryDrainIteratorGetNextRequest<T0, T1> {
15637 pub start_id: T0,
15638
15639 pub limit: T1,
15640 }
15641
15642 impl<T0, T1> ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest<T0, T1>
15643 where
15644 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15645 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
15646 {
15647 type Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest;
15648 }
15649
15650 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15651 for DictionaryDrainIteratorGetNextRequest<T0, T1>
15652 where
15653 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15654 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15655 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
15656 {
15657 #[inline]
15658 fn encode(
15659 self,
15660 encoder_: &mut ___E,
15661 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15662 _: (),
15663 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15664 ::fidl_next::munge! {
15665 let Self::Encoded {
15666
15667 start_id,
15668 limit,
15669
15670 } = out_;
15671 }
15672
15673 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
15674
15675 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
15676
15677 Ok(())
15678 }
15679 }
15680
15681 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
15682 pub items: T0,
15683
15684 pub end_id: T1,
15685 }
15686
15687 impl<T0, T1> ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse<T0, T1>
15688 where
15689 T0: ::fidl_next::Encodable<
15690 Encoded = ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
15691 >,
15692 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15693 {
15694 type Encoded = crate::wire::DictionaryDrainIteratorGetNextResponse<'static>;
15695 }
15696
15697 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15698 for DictionaryDrainIteratorGetNextResponse<T0, T1>
15699 where
15700 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15701 ___E: ::fidl_next::Encoder,
15702 ___E: ::fidl_next::fuchsia::HandleEncoder,
15703 T0: ::fidl_next::Encode<
15704 ___E,
15705 Encoded = ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
15706 >,
15707 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15708 {
15709 #[inline]
15710 fn encode(
15711 self,
15712 encoder_: &mut ___E,
15713 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15714 _: (),
15715 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15716 ::fidl_next::munge! {
15717 let Self::Encoded {
15718
15719 items,
15720 end_id,
15721
15722 } = out_;
15723 }
15724
15725 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
15726
15727 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
15728
15729 Ok(())
15730 }
15731 }
15732
15733 pub struct DictionaryEnumerateIteratorGetNextRequest<T0, T1> {
15734 pub start_id: T0,
15735
15736 pub limit: T1,
15737 }
15738
15739 impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
15740 where
15741 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15742 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
15743 {
15744 type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
15745 }
15746
15747 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15748 for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
15749 where
15750 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15751 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15752 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
15753 {
15754 #[inline]
15755 fn encode(
15756 self,
15757 encoder_: &mut ___E,
15758 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15759 _: (),
15760 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15761 ::fidl_next::munge! {
15762 let Self::Encoded {
15763
15764 start_id,
15765 limit,
15766
15767 } = out_;
15768 }
15769
15770 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
15771
15772 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
15773
15774 Ok(())
15775 }
15776 }
15777
15778 pub struct DictionaryOptionalItem<T0, T1> {
15779 pub key: T0,
15780
15781 pub value: T1,
15782 }
15783
15784 impl<T0, T1> ::fidl_next::Encodable for DictionaryOptionalItem<T0, T1>
15785 where
15786 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15787 T1: ::fidl_next::Encodable<
15788 Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15789 >,
15790 {
15791 type Encoded = crate::wire::DictionaryOptionalItem<'static>;
15792 }
15793
15794 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryOptionalItem<T0, T1>
15795 where
15796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15797 ___E: ::fidl_next::Encoder,
15798 ___E: ::fidl_next::fuchsia::HandleEncoder,
15799 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15800 T1: ::fidl_next::Encode<
15801 ___E,
15802 Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15803 >,
15804 {
15805 #[inline]
15806 fn encode(
15807 self,
15808 encoder_: &mut ___E,
15809 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15810 _: (),
15811 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15812 ::fidl_next::munge! {
15813 let Self::Encoded {
15814
15815 key,
15816 value,
15817
15818 } = out_;
15819 }
15820
15821 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15822
15823 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
15824
15825 Ok(())
15826 }
15827 }
15828
15829 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
15830 pub items: T0,
15831
15832 pub end_id: T1,
15833 }
15834
15835 impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
15836 where
15837 T0: ::fidl_next::Encodable<
15838 Encoded = ::fidl_next::WireVector<
15839 'static,
15840 crate::wire::DictionaryOptionalItem<'static>,
15841 >,
15842 >,
15843 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15844 {
15845 type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>;
15846 }
15847
15848 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15849 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
15850 where
15851 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15852 ___E: ::fidl_next::Encoder,
15853 ___E: ::fidl_next::fuchsia::HandleEncoder,
15854 T0: ::fidl_next::Encode<
15855 ___E,
15856 Encoded = ::fidl_next::WireVector<
15857 'static,
15858 crate::wire::DictionaryOptionalItem<'static>,
15859 >,
15860 >,
15861 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15862 {
15863 #[inline]
15864 fn encode(
15865 self,
15866 encoder_: &mut ___E,
15867 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15868 _: (),
15869 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15870 ::fidl_next::munge! {
15871 let Self::Encoded {
15872
15873 items,
15874 end_id,
15875
15876 } = out_;
15877 }
15878
15879 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
15880
15881 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
15882
15883 Ok(())
15884 }
15885 }
15886
15887 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
15888 pub keys: T0,
15889 }
15890
15891 impl<T0> ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse<T0>
15892 where
15893 T0: ::fidl_next::Encodable<
15894 Encoded = ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
15895 >,
15896 {
15897 type Encoded = crate::wire::DictionaryKeysIteratorGetNextResponse<'static>;
15898 }
15899
15900 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse<T0>
15901 where
15902 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15903 ___E: ::fidl_next::Encoder,
15904 ___E: ::fidl_next::fuchsia::HandleEncoder,
15905 T0: ::fidl_next::Encode<
15906 ___E,
15907 Encoded = ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
15908 >,
15909 {
15910 #[inline]
15911 fn encode(
15912 self,
15913 encoder_: &mut ___E,
15914 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15915 _: (),
15916 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15917 ::fidl_next::munge! {
15918 let Self::Encoded {
15919
15920 keys,
15921
15922 } = out_;
15923 }
15924
15925 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
15926
15927 Ok(())
15928 }
15929 }
15930
15931 pub struct DirReceiverReceiveRequest<T0> {
15932 pub channel: T0,
15933 }
15934
15935 impl<T0> ::fidl_next::Encodable for DirReceiverReceiveRequest<T0>
15936 where
15937 T0: ::fidl_next::Encodable<
15938 Encoded = ::fidl_next::ServerEnd<
15939 ::fidl_next_fuchsia_io::Directory,
15940 ::fidl_next::fuchsia::WireChannel,
15941 >,
15942 >,
15943 {
15944 type Encoded = crate::wire::DirReceiverReceiveRequest;
15945 }
15946
15947 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest<T0>
15948 where
15949 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15950 ___E: ::fidl_next::fuchsia::HandleEncoder,
15951 T0: ::fidl_next::Encode<
15952 ___E,
15953 Encoded = ::fidl_next::ServerEnd<
15954 ::fidl_next_fuchsia_io::Directory,
15955 ::fidl_next::fuchsia::WireChannel,
15956 >,
15957 >,
15958 {
15959 #[inline]
15960 fn encode(
15961 self,
15962 encoder_: &mut ___E,
15963 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15964 _: (),
15965 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15966 ::fidl_next::munge! {
15967 let Self::Encoded {
15968
15969 channel,
15970
15971 } = out_;
15972 }
15973
15974 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
15975
15976 Ok(())
15977 }
15978 }
15979
15980 pub struct ProtocolPayload<T0> {
15981 pub channel: T0,
15982 }
15983
15984 impl<T0> ::fidl_next::Encodable for ProtocolPayload<T0>
15985 where
15986 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
15987 {
15988 type Encoded = crate::wire::ProtocolPayload;
15989 }
15990
15991 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for ProtocolPayload<T0>
15992 where
15993 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15994 ___E: ::fidl_next::fuchsia::HandleEncoder,
15995 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
15996 {
15997 #[inline]
15998 fn encode(
15999 self,
16000 encoder_: &mut ___E,
16001 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
16002 _: (),
16003 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16004 ::fidl_next::munge! {
16005 let Self::Encoded {
16006
16007 channel,
16008
16009 } = out_;
16010 }
16011
16012 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
16013
16014 Ok(())
16015 }
16016 }
16017
16018 pub struct Unavailable {}
16019
16020 impl ::fidl_next::Encodable for Unavailable {
16021 type Encoded = crate::wire::Unavailable;
16022 }
16023
16024 unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
16025 where
16026 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16027 {
16028 #[inline]
16029 fn encode(
16030 self,
16031 encoder_: &mut ___E,
16032 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
16033 _: (),
16034 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16035 ::fidl_next::munge! {
16036 let Self::Encoded {
16037
16038 _empty,
16039
16040
16041 } = out_;
16042 }
16043
16044 Ok(())
16045 }
16046 }
16047}
16048
16049pub use self::natural::*;
16050
16051#[doc = " Maximum number of bytes in a [Data].\n"]
16052pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
16053
16054#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
16055pub const MAX_NAME_LENGTH: u64 = 255 as u64;
16056
16057#[doc = " Protocol that represents the concept of a \"capability store\", a repository\n for [Capability]s that are held by the component framework runtime.\n\n [CapabilityStore] serves as the main bridge between the component runtime and clients\n that enables them to operate on and exchange [Capability]s. A [CapabilityStore] instance\n contains a set of [Capability]s, each of which has a [CapabilityId] assigned by the client.\n\n Normally, a program would not exchange a [CapabilityStore] or [CapabilityId] with other\n programs -- a [CapabilityStore] connection and its enclosed capabilities are intended to\n be \"local\" to a program. Instead, if a program wishes to exchange a [Capability] with other\n programs, it should [Export] the [Capability] out of the store, send the [Capability] to the\n target program, which can then [Import] the capability into its own store.\n\n [CapabilityStore] is also used to manage capability lifetimes. The lifetime of a capability is\n scoped to the [CapabilityStore] in which it resides; i.e. to drop the [CapabilityStore]\n connections to release the capabilities instead it. In addition, [CapabilityStore] supports a\n [Drop] API to drop an individual [Capability] reference. (Note that it is possible for a\n some capabilities, like [DictionaryRef], to have multiple references, in which case all of\n the references must be dropped for the underlying resource to be released.)\n\n A note about semantics: the [CapabilityStore] APIs do not return [CapabilityId]s, because\n [CapabilityId]s are assigned by the client. Instead, when a method would semantically return\n a capability, this is expressed by taking the destination [CapabilityId] as an output parameter.\n"]
16059#[derive(PartialEq, Debug)]
16060pub struct CapabilityStore;
16061
16062impl ::fidl_next::Discoverable for CapabilityStore {
16063 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
16064}
16065
16066#[cfg(target_os = "fuchsia")]
16067impl ::fidl_next::HasTransport for CapabilityStore {
16068 type Transport = ::fidl_next::fuchsia::zx::Channel;
16069}
16070
16071pub mod capability_store {
16072 pub mod prelude {
16073 pub use crate::{
16074 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
16075 capability_store,
16076 };
16077
16078 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
16079
16080 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
16081
16082 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
16083
16084 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
16085
16086 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
16087
16088 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
16089
16090 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
16091
16092 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
16093
16094 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
16095
16096 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
16097
16098 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
16099
16100 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
16101
16102 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
16103
16104 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
16105
16106 pub use crate::natural::CapabilityStoreDropRequest;
16107
16108 pub use crate::natural::CapabilityStoreDuplicateRequest;
16109
16110 pub use crate::natural::CapabilityStoreError;
16111
16112 pub use crate::natural::CapabilityStoreExportRequest;
16113
16114 pub use crate::natural::CapabilityStoreImportRequest;
16115
16116 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
16117
16118 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
16119
16120 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
16121
16122 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
16123
16124 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
16125
16126 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
16127
16128 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
16129
16130 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
16131
16132 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
16133
16134 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
16135
16136 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
16137
16138 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
16139
16140 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
16141
16142 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
16143
16144 pub use crate::natural::CapabilityStoreDropResponse;
16145
16146 pub use crate::natural::CapabilityStoreDuplicateResponse;
16147
16148 pub use crate::natural::CapabilityStoreExportResponse;
16149
16150 pub use crate::natural::CapabilityStoreImportResponse;
16151 }
16152
16153 pub struct Duplicate;
16154
16155 impl ::fidl_next::Method for Duplicate {
16156 const ORDINAL: u64 = 6727592627741008260;
16157 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16158 ::fidl_next::protocol::Flexibility::Flexible;
16159
16160 type Protocol = crate::CapabilityStore;
16161
16162 type Request = crate::wire::CapabilityStoreDuplicateRequest;
16163
16164 type Response = ::fidl_next::WireFlexibleResult<
16165 'static,
16166 crate::wire::CapabilityStoreDuplicateResponse,
16167 crate::wire::CapabilityStoreError,
16168 >;
16169 }
16170
16171 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
16172 type Output = ::fidl_next::FlexibleResult<
16173 ___R,
16174 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16175 >;
16176
16177 fn respond(response: ___R) -> Self::Output {
16178 ::fidl_next::FlexibleResult::Ok(response)
16179 }
16180 }
16181
16182 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
16183 type Output = ::fidl_next::FlexibleResult<
16184 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDuplicateResponse>,
16185 ___R,
16186 >;
16187
16188 fn respond_err(response: ___R) -> Self::Output {
16189 ::fidl_next::FlexibleResult::Err(response)
16190 }
16191 }
16192
16193 pub struct Drop;
16194
16195 impl ::fidl_next::Method for Drop {
16196 const ORDINAL: u64 = 753328233834620249;
16197 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16198 ::fidl_next::protocol::Flexibility::Flexible;
16199
16200 type Protocol = crate::CapabilityStore;
16201
16202 type Request = crate::wire::CapabilityStoreDropRequest;
16203
16204 type Response = ::fidl_next::WireFlexibleResult<
16205 'static,
16206 crate::wire::CapabilityStoreDropResponse,
16207 crate::wire::CapabilityStoreError,
16208 >;
16209 }
16210
16211 impl<___R> ::fidl_next::Respond<___R> for Drop {
16212 type Output = ::fidl_next::FlexibleResult<
16213 ___R,
16214 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16215 >;
16216
16217 fn respond(response: ___R) -> Self::Output {
16218 ::fidl_next::FlexibleResult::Ok(response)
16219 }
16220 }
16221
16222 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
16223 type Output = ::fidl_next::FlexibleResult<
16224 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDropResponse>,
16225 ___R,
16226 >;
16227
16228 fn respond_err(response: ___R) -> Self::Output {
16229 ::fidl_next::FlexibleResult::Err(response)
16230 }
16231 }
16232
16233 pub struct Export;
16234
16235 impl ::fidl_next::Method for Export {
16236 const ORDINAL: u64 = 226159162093533951;
16237 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16238 ::fidl_next::protocol::Flexibility::Flexible;
16239
16240 type Protocol = crate::CapabilityStore;
16241
16242 type Request = crate::wire::CapabilityStoreExportRequest;
16243
16244 type Response = ::fidl_next::WireFlexibleResult<
16245 'static,
16246 crate::wire::CapabilityStoreExportResponse<'static>,
16247 crate::wire::CapabilityStoreError,
16248 >;
16249 }
16250
16251 impl<___R> ::fidl_next::Respond<___R> for Export {
16252 type Output = ::fidl_next::FlexibleResult<
16253 crate::generic::CapabilityStoreExportResponse<___R>,
16254 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16255 >;
16256
16257 fn respond(response: ___R) -> Self::Output {
16258 ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
16259 capability: response,
16260 })
16261 }
16262 }
16263
16264 impl<___R> ::fidl_next::RespondErr<___R> for Export {
16265 type Output = ::fidl_next::FlexibleResult<
16266 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreExportResponse<'static>>,
16267 ___R,
16268 >;
16269
16270 fn respond_err(response: ___R) -> Self::Output {
16271 ::fidl_next::FlexibleResult::Err(response)
16272 }
16273 }
16274
16275 pub struct Import;
16276
16277 impl ::fidl_next::Method for Import {
16278 const ORDINAL: u64 = 2276030276116435867;
16279 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16280 ::fidl_next::protocol::Flexibility::Flexible;
16281
16282 type Protocol = crate::CapabilityStore;
16283
16284 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
16285
16286 type Response = ::fidl_next::WireFlexibleResult<
16287 'static,
16288 crate::wire::CapabilityStoreImportResponse,
16289 crate::wire::CapabilityStoreError,
16290 >;
16291 }
16292
16293 impl<___R> ::fidl_next::Respond<___R> for Import {
16294 type Output = ::fidl_next::FlexibleResult<
16295 ___R,
16296 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16297 >;
16298
16299 fn respond(response: ___R) -> Self::Output {
16300 ::fidl_next::FlexibleResult::Ok(response)
16301 }
16302 }
16303
16304 impl<___R> ::fidl_next::RespondErr<___R> for Import {
16305 type Output = ::fidl_next::FlexibleResult<
16306 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreImportResponse>,
16307 ___R,
16308 >;
16309
16310 fn respond_err(response: ___R) -> Self::Output {
16311 ::fidl_next::FlexibleResult::Err(response)
16312 }
16313 }
16314
16315 pub struct ConnectorCreate;
16316
16317 impl ::fidl_next::Method for ConnectorCreate {
16318 const ORDINAL: u64 = 2979461408102095909;
16319 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16320 ::fidl_next::protocol::Flexibility::Flexible;
16321
16322 type Protocol = crate::CapabilityStore;
16323
16324 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
16325
16326 type Response = ::fidl_next::WireFlexibleResult<
16327 'static,
16328 crate::wire::CapabilityStoreConnectorCreateResponse,
16329 crate::wire::CapabilityStoreError,
16330 >;
16331 }
16332
16333 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
16334 type Output = ::fidl_next::FlexibleResult<
16335 ___R,
16336 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16337 >;
16338
16339 fn respond(response: ___R) -> Self::Output {
16340 ::fidl_next::FlexibleResult::Ok(response)
16341 }
16342 }
16343
16344 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
16345 type Output = ::fidl_next::FlexibleResult<
16346 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreConnectorCreateResponse>,
16347 ___R,
16348 >;
16349
16350 fn respond_err(response: ___R) -> Self::Output {
16351 ::fidl_next::FlexibleResult::Err(response)
16352 }
16353 }
16354
16355 pub struct ConnectorOpen;
16356
16357 impl ::fidl_next::Method for ConnectorOpen {
16358 const ORDINAL: u64 = 6016362336453278623;
16359 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16360 ::fidl_next::protocol::Flexibility::Flexible;
16361
16362 type Protocol = crate::CapabilityStore;
16363
16364 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
16365
16366 type Response = ::fidl_next::WireFlexibleResult<
16367 'static,
16368 crate::wire::CapabilityStoreConnectorOpenResponse,
16369 crate::wire::CapabilityStoreError,
16370 >;
16371 }
16372
16373 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
16374 type Output = ::fidl_next::FlexibleResult<
16375 ___R,
16376 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16377 >;
16378
16379 fn respond(response: ___R) -> Self::Output {
16380 ::fidl_next::FlexibleResult::Ok(response)
16381 }
16382 }
16383
16384 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
16385 type Output = ::fidl_next::FlexibleResult<
16386 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreConnectorOpenResponse>,
16387 ___R,
16388 >;
16389
16390 fn respond_err(response: ___R) -> Self::Output {
16391 ::fidl_next::FlexibleResult::Err(response)
16392 }
16393 }
16394
16395 pub struct DirConnectorCreate;
16396
16397 impl ::fidl_next::Method for DirConnectorCreate {
16398 const ORDINAL: u64 = 1756747594275428795;
16399 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16400 ::fidl_next::protocol::Flexibility::Flexible;
16401
16402 type Protocol = crate::CapabilityStore;
16403
16404 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
16405
16406 type Response = ::fidl_next::WireFlexibleResult<
16407 'static,
16408 crate::wire::CapabilityStoreDirConnectorCreateResponse,
16409 crate::wire::CapabilityStoreError,
16410 >;
16411 }
16412
16413 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
16414 type Output = ::fidl_next::FlexibleResult<
16415 ___R,
16416 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16417 >;
16418
16419 fn respond(response: ___R) -> Self::Output {
16420 ::fidl_next::FlexibleResult::Ok(response)
16421 }
16422 }
16423
16424 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
16425 type Output = ::fidl_next::FlexibleResult<
16426 ::fidl_next::util::EncodableNever<
16427 crate::wire::CapabilityStoreDirConnectorCreateResponse,
16428 >,
16429 ___R,
16430 >;
16431
16432 fn respond_err(response: ___R) -> Self::Output {
16433 ::fidl_next::FlexibleResult::Err(response)
16434 }
16435 }
16436
16437 pub struct DirConnectorOpen;
16438
16439 impl ::fidl_next::Method for DirConnectorOpen {
16440 const ORDINAL: u64 = 6219704004220369153;
16441 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16442 ::fidl_next::protocol::Flexibility::Flexible;
16443
16444 type Protocol = crate::CapabilityStore;
16445
16446 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest;
16447
16448 type Response = ::fidl_next::WireFlexibleResult<
16449 'static,
16450 crate::wire::CapabilityStoreDirConnectorOpenResponse,
16451 crate::wire::CapabilityStoreError,
16452 >;
16453 }
16454
16455 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
16456 type Output = ::fidl_next::FlexibleResult<
16457 ___R,
16458 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16459 >;
16460
16461 fn respond(response: ___R) -> Self::Output {
16462 ::fidl_next::FlexibleResult::Ok(response)
16463 }
16464 }
16465
16466 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
16467 type Output = ::fidl_next::FlexibleResult<
16468 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDirConnectorOpenResponse>,
16469 ___R,
16470 >;
16471
16472 fn respond_err(response: ___R) -> Self::Output {
16473 ::fidl_next::FlexibleResult::Err(response)
16474 }
16475 }
16476
16477 pub struct DictionaryCreate;
16478
16479 impl ::fidl_next::Method for DictionaryCreate {
16480 const ORDINAL: u64 = 7608770958894948499;
16481 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16482 ::fidl_next::protocol::Flexibility::Flexible;
16483
16484 type Protocol = crate::CapabilityStore;
16485
16486 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
16487
16488 type Response = ::fidl_next::WireFlexibleResult<
16489 'static,
16490 crate::wire::CapabilityStoreDictionaryCreateResponse,
16491 crate::wire::CapabilityStoreError,
16492 >;
16493 }
16494
16495 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
16496 type Output = ::fidl_next::FlexibleResult<
16497 ___R,
16498 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16499 >;
16500
16501 fn respond(response: ___R) -> Self::Output {
16502 ::fidl_next::FlexibleResult::Ok(response)
16503 }
16504 }
16505
16506 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
16507 type Output = ::fidl_next::FlexibleResult<
16508 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryCreateResponse>,
16509 ___R,
16510 >;
16511
16512 fn respond_err(response: ___R) -> Self::Output {
16513 ::fidl_next::FlexibleResult::Err(response)
16514 }
16515 }
16516
16517 pub struct DictionaryLegacyImport;
16518
16519 impl ::fidl_next::Method for DictionaryLegacyImport {
16520 const ORDINAL: u64 = 8285893703432012383;
16521 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16522 ::fidl_next::protocol::Flexibility::Flexible;
16523
16524 type Protocol = crate::CapabilityStore;
16525
16526 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
16527
16528 type Response = ::fidl_next::WireFlexibleResult<
16529 'static,
16530 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
16531 crate::wire::CapabilityStoreError,
16532 >;
16533 }
16534
16535 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
16536 type Output = ::fidl_next::FlexibleResult<
16537 ___R,
16538 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16539 >;
16540
16541 fn respond(response: ___R) -> Self::Output {
16542 ::fidl_next::FlexibleResult::Ok(response)
16543 }
16544 }
16545
16546 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
16547 type Output = ::fidl_next::FlexibleResult<
16548 ::fidl_next::util::EncodableNever<
16549 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
16550 >,
16551 ___R,
16552 >;
16553
16554 fn respond_err(response: ___R) -> Self::Output {
16555 ::fidl_next::FlexibleResult::Err(response)
16556 }
16557 }
16558
16559 pub struct DictionaryLegacyExport;
16560
16561 impl ::fidl_next::Method for DictionaryLegacyExport {
16562 const ORDINAL: u64 = 4647175832683306445;
16563 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16564 ::fidl_next::protocol::Flexibility::Flexible;
16565
16566 type Protocol = crate::CapabilityStore;
16567
16568 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
16569
16570 type Response = ::fidl_next::WireFlexibleResult<
16571 'static,
16572 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
16573 crate::wire::CapabilityStoreError,
16574 >;
16575 }
16576
16577 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
16578 type Output = ::fidl_next::FlexibleResult<
16579 ___R,
16580 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16581 >;
16582
16583 fn respond(response: ___R) -> Self::Output {
16584 ::fidl_next::FlexibleResult::Ok(response)
16585 }
16586 }
16587
16588 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
16589 type Output = ::fidl_next::FlexibleResult<
16590 ::fidl_next::util::EncodableNever<
16591 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
16592 >,
16593 ___R,
16594 >;
16595
16596 fn respond_err(response: ___R) -> Self::Output {
16597 ::fidl_next::FlexibleResult::Err(response)
16598 }
16599 }
16600
16601 pub struct DictionaryInsert;
16602
16603 impl ::fidl_next::Method for DictionaryInsert {
16604 const ORDINAL: u64 = 8575443262986538023;
16605 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16606 ::fidl_next::protocol::Flexibility::Flexible;
16607
16608 type Protocol = crate::CapabilityStore;
16609
16610 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
16611
16612 type Response = ::fidl_next::WireFlexibleResult<
16613 'static,
16614 crate::wire::CapabilityStoreDictionaryInsertResponse,
16615 crate::wire::CapabilityStoreError,
16616 >;
16617 }
16618
16619 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
16620 type Output = ::fidl_next::FlexibleResult<
16621 ___R,
16622 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16623 >;
16624
16625 fn respond(response: ___R) -> Self::Output {
16626 ::fidl_next::FlexibleResult::Ok(response)
16627 }
16628 }
16629
16630 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
16631 type Output = ::fidl_next::FlexibleResult<
16632 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryInsertResponse>,
16633 ___R,
16634 >;
16635
16636 fn respond_err(response: ___R) -> Self::Output {
16637 ::fidl_next::FlexibleResult::Err(response)
16638 }
16639 }
16640
16641 pub struct DictionaryGet;
16642
16643 impl ::fidl_next::Method for DictionaryGet {
16644 const ORDINAL: u64 = 5592951026866236882;
16645 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16646 ::fidl_next::protocol::Flexibility::Flexible;
16647
16648 type Protocol = crate::CapabilityStore;
16649
16650 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
16651
16652 type Response = ::fidl_next::WireFlexibleResult<
16653 'static,
16654 crate::wire::CapabilityStoreDictionaryGetResponse,
16655 crate::wire::CapabilityStoreError,
16656 >;
16657 }
16658
16659 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
16660 type Output = ::fidl_next::FlexibleResult<
16661 ___R,
16662 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16663 >;
16664
16665 fn respond(response: ___R) -> Self::Output {
16666 ::fidl_next::FlexibleResult::Ok(response)
16667 }
16668 }
16669
16670 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
16671 type Output = ::fidl_next::FlexibleResult<
16672 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryGetResponse>,
16673 ___R,
16674 >;
16675
16676 fn respond_err(response: ___R) -> Self::Output {
16677 ::fidl_next::FlexibleResult::Err(response)
16678 }
16679 }
16680
16681 pub struct DictionaryRemove;
16682
16683 impl ::fidl_next::Method for DictionaryRemove {
16684 const ORDINAL: u64 = 343892214579320051;
16685 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16686 ::fidl_next::protocol::Flexibility::Flexible;
16687
16688 type Protocol = crate::CapabilityStore;
16689
16690 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
16691
16692 type Response = ::fidl_next::WireFlexibleResult<
16693 'static,
16694 crate::wire::CapabilityStoreDictionaryRemoveResponse,
16695 crate::wire::CapabilityStoreError,
16696 >;
16697 }
16698
16699 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
16700 type Output = ::fidl_next::FlexibleResult<
16701 ___R,
16702 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16703 >;
16704
16705 fn respond(response: ___R) -> Self::Output {
16706 ::fidl_next::FlexibleResult::Ok(response)
16707 }
16708 }
16709
16710 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
16711 type Output = ::fidl_next::FlexibleResult<
16712 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryRemoveResponse>,
16713 ___R,
16714 >;
16715
16716 fn respond_err(response: ___R) -> Self::Output {
16717 ::fidl_next::FlexibleResult::Err(response)
16718 }
16719 }
16720
16721 pub struct DictionaryCopy;
16722
16723 impl ::fidl_next::Method for DictionaryCopy {
16724 const ORDINAL: u64 = 3977783339739362383;
16725 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16726 ::fidl_next::protocol::Flexibility::Flexible;
16727
16728 type Protocol = crate::CapabilityStore;
16729
16730 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
16731
16732 type Response = ::fidl_next::WireFlexibleResult<
16733 'static,
16734 crate::wire::CapabilityStoreDictionaryCopyResponse,
16735 crate::wire::CapabilityStoreError,
16736 >;
16737 }
16738
16739 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
16740 type Output = ::fidl_next::FlexibleResult<
16741 ___R,
16742 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16743 >;
16744
16745 fn respond(response: ___R) -> Self::Output {
16746 ::fidl_next::FlexibleResult::Ok(response)
16747 }
16748 }
16749
16750 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
16751 type Output = ::fidl_next::FlexibleResult<
16752 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryCopyResponse>,
16753 ___R,
16754 >;
16755
16756 fn respond_err(response: ___R) -> Self::Output {
16757 ::fidl_next::FlexibleResult::Err(response)
16758 }
16759 }
16760
16761 pub struct DictionaryKeys;
16762
16763 impl ::fidl_next::Method for DictionaryKeys {
16764 const ORDINAL: u64 = 597577248872787102;
16765 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16766 ::fidl_next::protocol::Flexibility::Flexible;
16767
16768 type Protocol = crate::CapabilityStore;
16769
16770 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
16771
16772 type Response = ::fidl_next::WireFlexibleResult<
16773 'static,
16774 crate::wire::CapabilityStoreDictionaryKeysResponse,
16775 crate::wire::CapabilityStoreError,
16776 >;
16777 }
16778
16779 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
16780 type Output = ::fidl_next::FlexibleResult<
16781 ___R,
16782 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16783 >;
16784
16785 fn respond(response: ___R) -> Self::Output {
16786 ::fidl_next::FlexibleResult::Ok(response)
16787 }
16788 }
16789
16790 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
16791 type Output = ::fidl_next::FlexibleResult<
16792 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryKeysResponse>,
16793 ___R,
16794 >;
16795
16796 fn respond_err(response: ___R) -> Self::Output {
16797 ::fidl_next::FlexibleResult::Err(response)
16798 }
16799 }
16800
16801 pub struct DictionaryEnumerate;
16802
16803 impl ::fidl_next::Method for DictionaryEnumerate {
16804 const ORDINAL: u64 = 964467096271472193;
16805 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16806 ::fidl_next::protocol::Flexibility::Flexible;
16807
16808 type Protocol = crate::CapabilityStore;
16809
16810 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
16811
16812 type Response = ::fidl_next::WireFlexibleResult<
16813 'static,
16814 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
16815 crate::wire::CapabilityStoreError,
16816 >;
16817 }
16818
16819 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
16820 type Output = ::fidl_next::FlexibleResult<
16821 ___R,
16822 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16823 >;
16824
16825 fn respond(response: ___R) -> Self::Output {
16826 ::fidl_next::FlexibleResult::Ok(response)
16827 }
16828 }
16829
16830 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
16831 type Output = ::fidl_next::FlexibleResult<
16832 ::fidl_next::util::EncodableNever<
16833 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
16834 >,
16835 ___R,
16836 >;
16837
16838 fn respond_err(response: ___R) -> Self::Output {
16839 ::fidl_next::FlexibleResult::Err(response)
16840 }
16841 }
16842
16843 pub struct DictionaryDrain;
16844
16845 impl ::fidl_next::Method for DictionaryDrain {
16846 const ORDINAL: u64 = 2928364469569621208;
16847 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16848 ::fidl_next::protocol::Flexibility::Flexible;
16849
16850 type Protocol = crate::CapabilityStore;
16851
16852 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
16853
16854 type Response = ::fidl_next::WireFlexibleResult<
16855 'static,
16856 crate::wire::CapabilityStoreDictionaryDrainResponse,
16857 crate::wire::CapabilityStoreError,
16858 >;
16859 }
16860
16861 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
16862 type Output = ::fidl_next::FlexibleResult<
16863 ___R,
16864 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16865 >;
16866
16867 fn respond(response: ___R) -> Self::Output {
16868 ::fidl_next::FlexibleResult::Ok(response)
16869 }
16870 }
16871
16872 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
16873 type Output = ::fidl_next::FlexibleResult<
16874 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryDrainResponse>,
16875 ___R,
16876 >;
16877
16878 fn respond_err(response: ___R) -> Self::Output {
16879 ::fidl_next::FlexibleResult::Err(response)
16880 }
16881 }
16882
16883 mod ___detail {
16884 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
16885 where
16886 ___T: ::fidl_next::Transport,
16887 {
16888 type Client = CapabilityStoreClient<___T>;
16889 type Server = CapabilityStoreServer<___T>;
16890 }
16891
16892 #[repr(transparent)]
16894 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
16895 #[allow(dead_code)]
16896 client: ::fidl_next::protocol::Client<___T>,
16897 }
16898
16899 impl<___T> CapabilityStoreClient<___T>
16900 where
16901 ___T: ::fidl_next::Transport,
16902 {
16903 #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
16904 pub fn duplicate(
16905 &self,
16906
16907 id: impl ::fidl_next::Encode<
16908 <___T as ::fidl_next::Transport>::SendBuffer,
16909 Encoded = ::fidl_next::WireU64,
16910 >,
16911
16912 dest_id: impl ::fidl_next::Encode<
16913 <___T as ::fidl_next::Transport>::SendBuffer,
16914 Encoded = ::fidl_next::WireU64,
16915 >,
16916 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
16917 where
16918 <___T as ::fidl_next::Transport>::SendBuffer:
16919 ::fidl_next::encoder::InternalHandleEncoder,
16920 {
16921 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
16922 }
16923
16924 #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
16925 pub fn duplicate_with<___R>(
16926 &self,
16927 request: ___R,
16928 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
16929 where
16930 ___R: ::fidl_next::Encode<
16931 <___T as ::fidl_next::Transport>::SendBuffer,
16932 Encoded = crate::wire::CapabilityStoreDuplicateRequest,
16933 >,
16934 {
16935 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
16936 6727592627741008260,
16937 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
16938 request,
16939 ))
16940 }
16941
16942 #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
16943 pub fn drop(
16944 &self,
16945
16946 id: impl ::fidl_next::Encode<
16947 <___T as ::fidl_next::Transport>::SendBuffer,
16948 Encoded = ::fidl_next::WireU64,
16949 >,
16950 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
16951 where
16952 <___T as ::fidl_next::Transport>::SendBuffer:
16953 ::fidl_next::encoder::InternalHandleEncoder,
16954 {
16955 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
16956 }
16957
16958 #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
16959 pub fn drop_with<___R>(
16960 &self,
16961 request: ___R,
16962 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
16963 where
16964 ___R: ::fidl_next::Encode<
16965 <___T as ::fidl_next::Transport>::SendBuffer,
16966 Encoded = crate::wire::CapabilityStoreDropRequest,
16967 >,
16968 {
16969 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
16970 753328233834620249,
16971 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
16972 request,
16973 ))
16974 }
16975
16976 #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
16977 pub fn export(
16978 &self,
16979
16980 id: impl ::fidl_next::Encode<
16981 <___T as ::fidl_next::Transport>::SendBuffer,
16982 Encoded = ::fidl_next::WireU64,
16983 >,
16984 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
16985 where
16986 <___T as ::fidl_next::Transport>::SendBuffer:
16987 ::fidl_next::encoder::InternalHandleEncoder,
16988 {
16989 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
16990 }
16991
16992 #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
16993 pub fn export_with<___R>(
16994 &self,
16995 request: ___R,
16996 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
16997 where
16998 ___R: ::fidl_next::Encode<
16999 <___T as ::fidl_next::Transport>::SendBuffer,
17000 Encoded = crate::wire::CapabilityStoreExportRequest,
17001 >,
17002 {
17003 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17004 226159162093533951,
17005 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
17006 request,
17007 ))
17008 }
17009
17010 #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
17011 pub fn import(
17012 &self,
17013
17014 id: impl ::fidl_next::Encode<
17015 <___T as ::fidl_next::Transport>::SendBuffer,
17016 Encoded = ::fidl_next::WireU64,
17017 >,
17018
17019 capability: impl ::fidl_next::Encode<
17020 <___T as ::fidl_next::Transport>::SendBuffer,
17021 Encoded = crate::wire::Capability<'static>,
17022 >,
17023 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
17024 where
17025 <___T as ::fidl_next::Transport>::SendBuffer:
17026 ::fidl_next::encoder::InternalHandleEncoder,
17027 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17028 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17029 {
17030 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
17031 }
17032
17033 #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
17034 pub fn import_with<___R>(
17035 &self,
17036 request: ___R,
17037 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
17038 where
17039 ___R: ::fidl_next::Encode<
17040 <___T as ::fidl_next::Transport>::SendBuffer,
17041 Encoded = crate::wire::CapabilityStoreImportRequest<'static>,
17042 >,
17043 {
17044 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17045 2276030276116435867,
17046 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
17047 request,
17048 ))
17049 }
17050
17051 #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17052 pub fn connector_create(
17053 &self,
17054
17055 id: impl ::fidl_next::Encode<
17056 <___T as ::fidl_next::Transport>::SendBuffer,
17057 Encoded = ::fidl_next::WireU64,
17058 >,
17059
17060 receiver: impl ::fidl_next::Encode<
17061 <___T as ::fidl_next::Transport>::SendBuffer,
17062 Encoded = ::fidl_next::ClientEnd<
17063 crate::Receiver,
17064 ::fidl_next::fuchsia::WireChannel,
17065 >,
17066 >,
17067 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
17068 where
17069 <___T as ::fidl_next::Transport>::SendBuffer:
17070 ::fidl_next::encoder::InternalHandleEncoder,
17071 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17072 {
17073 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
17074 id,
17075
17076 receiver,
17077 })
17078 }
17079
17080 #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17081 pub fn connector_create_with<___R>(
17082 &self,
17083 request: ___R,
17084 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
17085 where
17086 ___R: ::fidl_next::Encode<
17087 <___T as ::fidl_next::Transport>::SendBuffer,
17088 Encoded = crate::wire::CapabilityStoreConnectorCreateRequest,
17089 >,
17090 {
17091 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17092 2979461408102095909,
17093 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
17094 request,
17095 ))
17096 }
17097
17098 #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17099 pub fn connector_open(
17100 &self,
17101
17102 id: impl ::fidl_next::Encode<
17103 <___T as ::fidl_next::Transport>::SendBuffer,
17104 Encoded = ::fidl_next::WireU64,
17105 >,
17106
17107 server_end: impl ::fidl_next::Encode<
17108 <___T as ::fidl_next::Transport>::SendBuffer,
17109 Encoded = ::fidl_next::fuchsia::WireChannel,
17110 >,
17111 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
17112 where
17113 <___T as ::fidl_next::Transport>::SendBuffer:
17114 ::fidl_next::encoder::InternalHandleEncoder,
17115 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17116 {
17117 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
17118 id,
17119
17120 server_end,
17121 })
17122 }
17123
17124 #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17125 pub fn connector_open_with<___R>(
17126 &self,
17127 request: ___R,
17128 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
17129 where
17130 ___R: ::fidl_next::Encode<
17131 <___T as ::fidl_next::Transport>::SendBuffer,
17132 Encoded = crate::wire::CapabilityStoreConnectorOpenRequest,
17133 >,
17134 {
17135 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17136 6016362336453278623,
17137 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
17138 request,
17139 ))
17140 }
17141
17142 #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17143 pub fn dir_connector_create(
17144 &self,
17145
17146 id: impl ::fidl_next::Encode<
17147 <___T as ::fidl_next::Transport>::SendBuffer,
17148 Encoded = ::fidl_next::WireU64,
17149 >,
17150
17151 receiver: impl ::fidl_next::Encode<
17152 <___T as ::fidl_next::Transport>::SendBuffer,
17153 Encoded = ::fidl_next::ClientEnd<
17154 crate::DirReceiver,
17155 ::fidl_next::fuchsia::WireChannel,
17156 >,
17157 >,
17158 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
17159 where
17160 <___T as ::fidl_next::Transport>::SendBuffer:
17161 ::fidl_next::encoder::InternalHandleEncoder,
17162 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17163 {
17164 self.dir_connector_create_with(
17165 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
17166 )
17167 }
17168
17169 #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17170 pub fn dir_connector_create_with<___R>(
17171 &self,
17172 request: ___R,
17173 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
17174 where
17175 ___R: ::fidl_next::Encode<
17176 <___T as ::fidl_next::Transport>::SendBuffer,
17177 Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest,
17178 >,
17179 {
17180 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17181 1756747594275428795,
17182 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
17183 request,
17184 ))
17185 }
17186
17187 #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17188 pub fn dir_connector_open(
17189 &self,
17190
17191 id: impl ::fidl_next::Encode<
17192 <___T as ::fidl_next::Transport>::SendBuffer,
17193 Encoded = ::fidl_next::WireU64,
17194 >,
17195
17196 server_end: impl ::fidl_next::Encode<
17197 <___T as ::fidl_next::Transport>::SendBuffer,
17198 Encoded = ::fidl_next::ServerEnd<
17199 ::fidl_next_fuchsia_io::Directory,
17200 ::fidl_next::fuchsia::WireChannel,
17201 >,
17202 >,
17203 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
17204 where
17205 <___T as ::fidl_next::Transport>::SendBuffer:
17206 ::fidl_next::encoder::InternalHandleEncoder,
17207 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17208 {
17209 self.dir_connector_open_with(
17210 crate::generic::CapabilityStoreDirConnectorOpenRequest { id, server_end },
17211 )
17212 }
17213
17214 #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17215 pub fn dir_connector_open_with<___R>(
17216 &self,
17217 request: ___R,
17218 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
17219 where
17220 ___R: ::fidl_next::Encode<
17221 <___T as ::fidl_next::Transport>::SendBuffer,
17222 Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest,
17223 >,
17224 {
17225 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17226 6219704004220369153,
17227 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
17228 request,
17229 ))
17230 }
17231
17232 #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17233 pub fn dictionary_create(
17234 &self,
17235
17236 id: impl ::fidl_next::Encode<
17237 <___T as ::fidl_next::Transport>::SendBuffer,
17238 Encoded = ::fidl_next::WireU64,
17239 >,
17240 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
17241 where
17242 <___T as ::fidl_next::Transport>::SendBuffer:
17243 ::fidl_next::encoder::InternalHandleEncoder,
17244 {
17245 self.dictionary_create_with(
17246 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
17247 )
17248 }
17249
17250 #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17251 pub fn dictionary_create_with<___R>(
17252 &self,
17253 request: ___R,
17254 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
17255 where
17256 ___R: ::fidl_next::Encode<
17257 <___T as ::fidl_next::Transport>::SendBuffer,
17258 Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest,
17259 >,
17260 {
17261 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17262 7608770958894948499,
17263 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
17264 request,
17265 ))
17266 }
17267
17268 #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
17269 pub fn dictionary_legacy_import(
17270 &self,
17271
17272 id: impl ::fidl_next::Encode<
17273 <___T as ::fidl_next::Transport>::SendBuffer,
17274 Encoded = ::fidl_next::WireU64,
17275 >,
17276
17277 client_end: impl ::fidl_next::Encode<
17278 <___T as ::fidl_next::Transport>::SendBuffer,
17279 Encoded = ::fidl_next::fuchsia::WireChannel,
17280 >,
17281 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
17282 where
17283 <___T as ::fidl_next::Transport>::SendBuffer:
17284 ::fidl_next::encoder::InternalHandleEncoder,
17285 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17286 {
17287 self.dictionary_legacy_import_with(
17288 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
17289 )
17290 }
17291
17292 #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
17293 pub fn dictionary_legacy_import_with<___R>(
17294 &self,
17295 request: ___R,
17296 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
17297 where
17298 ___R: ::fidl_next::Encode<
17299 <___T as ::fidl_next::Transport>::SendBuffer,
17300 Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
17301 >,
17302 {
17303 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17304 8285893703432012383,
17305 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
17306 request,
17307 ))
17308 }
17309
17310 #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
17311 pub fn dictionary_legacy_export(
17312 &self,
17313
17314 id: impl ::fidl_next::Encode<
17315 <___T as ::fidl_next::Transport>::SendBuffer,
17316 Encoded = ::fidl_next::WireU64,
17317 >,
17318
17319 server_end: impl ::fidl_next::Encode<
17320 <___T as ::fidl_next::Transport>::SendBuffer,
17321 Encoded = ::fidl_next::fuchsia::WireChannel,
17322 >,
17323 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
17324 where
17325 <___T as ::fidl_next::Transport>::SendBuffer:
17326 ::fidl_next::encoder::InternalHandleEncoder,
17327 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17328 {
17329 self.dictionary_legacy_export_with(
17330 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
17331 )
17332 }
17333
17334 #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
17335 pub fn dictionary_legacy_export_with<___R>(
17336 &self,
17337 request: ___R,
17338 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
17339 where
17340 ___R: ::fidl_next::Encode<
17341 <___T as ::fidl_next::Transport>::SendBuffer,
17342 Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
17343 >,
17344 {
17345 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17346 4647175832683306445,
17347 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
17348 request,
17349 ))
17350 }
17351
17352 #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
17353 pub fn dictionary_insert(
17354 &self,
17355
17356 id: impl ::fidl_next::Encode<
17357 <___T as ::fidl_next::Transport>::SendBuffer,
17358 Encoded = ::fidl_next::WireU64,
17359 >,
17360
17361 item: impl ::fidl_next::Encode<
17362 <___T as ::fidl_next::Transport>::SendBuffer,
17363 Encoded = crate::wire::DictionaryItem<'static>,
17364 >,
17365 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
17366 where
17367 <___T as ::fidl_next::Transport>::SendBuffer:
17368 ::fidl_next::encoder::InternalHandleEncoder,
17369 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17370 {
17371 self.dictionary_insert_with(
17372 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
17373 )
17374 }
17375
17376 #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
17377 pub fn dictionary_insert_with<___R>(
17378 &self,
17379 request: ___R,
17380 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
17381 where
17382 ___R: ::fidl_next::Encode<
17383 <___T as ::fidl_next::Transport>::SendBuffer,
17384 Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
17385 >,
17386 {
17387 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17388 8575443262986538023,
17389 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
17390 request,
17391 ))
17392 }
17393
17394 #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
17395 pub fn dictionary_get(
17396 &self,
17397
17398 id: impl ::fidl_next::Encode<
17399 <___T as ::fidl_next::Transport>::SendBuffer,
17400 Encoded = ::fidl_next::WireU64,
17401 >,
17402
17403 key: impl ::fidl_next::Encode<
17404 <___T as ::fidl_next::Transport>::SendBuffer,
17405 Encoded = ::fidl_next::WireString<'static>,
17406 >,
17407
17408 dest_id: impl ::fidl_next::Encode<
17409 <___T as ::fidl_next::Transport>::SendBuffer,
17410 Encoded = ::fidl_next::WireU64,
17411 >,
17412 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
17413 where
17414 <___T as ::fidl_next::Transport>::SendBuffer:
17415 ::fidl_next::encoder::InternalHandleEncoder,
17416 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17417 {
17418 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
17419 id,
17420
17421 key,
17422
17423 dest_id,
17424 })
17425 }
17426
17427 #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
17428 pub fn dictionary_get_with<___R>(
17429 &self,
17430 request: ___R,
17431 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
17432 where
17433 ___R: ::fidl_next::Encode<
17434 <___T as ::fidl_next::Transport>::SendBuffer,
17435 Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
17436 >,
17437 {
17438 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17439 5592951026866236882,
17440 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
17441 request,
17442 ))
17443 }
17444
17445 #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
17446 pub fn dictionary_remove(
17447 &self,
17448
17449 id: impl ::fidl_next::Encode<
17450 <___T as ::fidl_next::Transport>::SendBuffer,
17451 Encoded = ::fidl_next::WireU64,
17452 >,
17453
17454 key: impl ::fidl_next::Encode<
17455 <___T as ::fidl_next::Transport>::SendBuffer,
17456 Encoded = ::fidl_next::WireString<'static>,
17457 >,
17458
17459 dest_id: impl ::fidl_next::Encode<
17460 <___T as ::fidl_next::Transport>::SendBuffer,
17461 Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
17462 >,
17463 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
17464 where
17465 <___T as ::fidl_next::Transport>::SendBuffer:
17466 ::fidl_next::encoder::InternalHandleEncoder,
17467 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17468 {
17469 self.dictionary_remove_with(
17470 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
17471 )
17472 }
17473
17474 #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
17475 pub fn dictionary_remove_with<___R>(
17476 &self,
17477 request: ___R,
17478 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
17479 where
17480 ___R: ::fidl_next::Encode<
17481 <___T as ::fidl_next::Transport>::SendBuffer,
17482 Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
17483 >,
17484 {
17485 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17486 343892214579320051,
17487 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
17488 request,
17489 ))
17490 }
17491
17492 #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
17493 pub fn dictionary_copy(
17494 &self,
17495
17496 id: impl ::fidl_next::Encode<
17497 <___T as ::fidl_next::Transport>::SendBuffer,
17498 Encoded = ::fidl_next::WireU64,
17499 >,
17500
17501 dest_id: impl ::fidl_next::Encode<
17502 <___T as ::fidl_next::Transport>::SendBuffer,
17503 Encoded = ::fidl_next::WireU64,
17504 >,
17505 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
17506 where
17507 <___T as ::fidl_next::Transport>::SendBuffer:
17508 ::fidl_next::encoder::InternalHandleEncoder,
17509 {
17510 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
17511 id,
17512
17513 dest_id,
17514 })
17515 }
17516
17517 #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
17518 pub fn dictionary_copy_with<___R>(
17519 &self,
17520 request: ___R,
17521 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
17522 where
17523 ___R: ::fidl_next::Encode<
17524 <___T as ::fidl_next::Transport>::SendBuffer,
17525 Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest,
17526 >,
17527 {
17528 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17529 3977783339739362383,
17530 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
17531 request,
17532 ))
17533 }
17534
17535 #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17536 pub fn dictionary_keys(
17537 &self,
17538
17539 id: impl ::fidl_next::Encode<
17540 <___T as ::fidl_next::Transport>::SendBuffer,
17541 Encoded = ::fidl_next::WireU64,
17542 >,
17543
17544 iterator: impl ::fidl_next::Encode<
17545 <___T as ::fidl_next::Transport>::SendBuffer,
17546 Encoded = ::fidl_next::ServerEnd<
17547 crate::DictionaryKeysIterator,
17548 ::fidl_next::fuchsia::WireChannel,
17549 >,
17550 >,
17551 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
17552 where
17553 <___T as ::fidl_next::Transport>::SendBuffer:
17554 ::fidl_next::encoder::InternalHandleEncoder,
17555 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17556 {
17557 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
17558 id,
17559
17560 iterator,
17561 })
17562 }
17563
17564 #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17565 pub fn dictionary_keys_with<___R>(
17566 &self,
17567 request: ___R,
17568 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
17569 where
17570 ___R: ::fidl_next::Encode<
17571 <___T as ::fidl_next::Transport>::SendBuffer,
17572 Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest,
17573 >,
17574 {
17575 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17576 597577248872787102,
17577 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
17578 request,
17579 ))
17580 }
17581
17582 #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17583 pub fn dictionary_enumerate(
17584 &self,
17585
17586 id: impl ::fidl_next::Encode<
17587 <___T as ::fidl_next::Transport>::SendBuffer,
17588 Encoded = ::fidl_next::WireU64,
17589 >,
17590
17591 iterator: impl ::fidl_next::Encode<
17592 <___T as ::fidl_next::Transport>::SendBuffer,
17593 Encoded = ::fidl_next::ServerEnd<
17594 crate::DictionaryEnumerateIterator,
17595 ::fidl_next::fuchsia::WireChannel,
17596 >,
17597 >,
17598 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
17599 where
17600 <___T as ::fidl_next::Transport>::SendBuffer:
17601 ::fidl_next::encoder::InternalHandleEncoder,
17602 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17603 {
17604 self.dictionary_enumerate_with(
17605 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
17606 )
17607 }
17608
17609 #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17610 pub fn dictionary_enumerate_with<___R>(
17611 &self,
17612 request: ___R,
17613 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
17614 where
17615 ___R: ::fidl_next::Encode<
17616 <___T as ::fidl_next::Transport>::SendBuffer,
17617 Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest,
17618 >,
17619 {
17620 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17621 964467096271472193,
17622 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
17623 request,
17624 ))
17625 }
17626
17627 #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17628 pub fn dictionary_drain(
17629 &self,
17630
17631 id: impl ::fidl_next::Encode<
17632 <___T as ::fidl_next::Transport>::SendBuffer,
17633 Encoded = ::fidl_next::WireU64,
17634 >,
17635
17636 iterator: impl ::fidl_next::Encode<
17637 <___T as ::fidl_next::Transport>::SendBuffer,
17638 Encoded = ::fidl_next::ServerEnd<
17639 crate::DictionaryDrainIterator,
17640 ::fidl_next::fuchsia::WireOptionalChannel,
17641 >,
17642 >,
17643 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
17644 where
17645 <___T as ::fidl_next::Transport>::SendBuffer:
17646 ::fidl_next::encoder::InternalHandleEncoder,
17647 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17648 {
17649 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
17650 id,
17651
17652 iterator,
17653 })
17654 }
17655
17656 #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17657 pub fn dictionary_drain_with<___R>(
17658 &self,
17659 request: ___R,
17660 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
17661 where
17662 ___R: ::fidl_next::Encode<
17663 <___T as ::fidl_next::Transport>::SendBuffer,
17664 Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest,
17665 >,
17666 {
17667 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17668 2928364469569621208,
17669 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
17670 request,
17671 ))
17672 }
17673 }
17674
17675 #[repr(transparent)]
17677 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
17678 server: ::fidl_next::protocol::Server<___T>,
17679 }
17680
17681 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
17682 }
17683}
17684
17685pub trait CapabilityStoreClientHandler<
17689 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17690 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17691>
17692{
17693 fn on_unknown_interaction(
17694 &mut self,
17695 ordinal: u64,
17696 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17697 ::core::future::ready(())
17698 }
17699}
17700
17701impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
17702where
17703 ___T: ::fidl_next::Transport,
17704{
17705 async fn on_unknown_interaction(&mut self, _: u64) {}
17706}
17707
17708impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
17709where
17710 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
17711 ___T: ::fidl_next::Transport,
17712 <capability_store::Duplicate as ::fidl_next::Method>::Response:
17713 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17714 <capability_store::Drop as ::fidl_next::Method>::Response:
17715 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17716 <capability_store::Export as ::fidl_next::Method>::Response:
17717 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17718 <capability_store::Import as ::fidl_next::Method>::Response:
17719 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17720 <capability_store::ConnectorCreate as ::fidl_next::Method>::Response:
17721 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17722 <capability_store::ConnectorOpen as ::fidl_next::Method>::Response:
17723 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17724 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Response:
17725 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17726 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Response:
17727 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17728 <capability_store::DictionaryCreate as ::fidl_next::Method>::Response:
17729 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17730 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Response:
17731 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17732 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Response:
17733 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17734 <capability_store::DictionaryInsert as ::fidl_next::Method>::Response:
17735 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17736 <capability_store::DictionaryGet as ::fidl_next::Method>::Response:
17737 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17738 <capability_store::DictionaryRemove as ::fidl_next::Method>::Response:
17739 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17740 <capability_store::DictionaryCopy as ::fidl_next::Method>::Response:
17741 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17742 <capability_store::DictionaryKeys as ::fidl_next::Method>::Response:
17743 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17744 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Response:
17745 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17746 <capability_store::DictionaryDrain as ::fidl_next::Method>::Response:
17747 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17748{
17749 async fn on_event(
17750 handler: &mut ___H,
17751 ordinal: u64,
17752 flexibility: ::fidl_next::protocol::Flexibility,
17753 buffer: ___T::RecvBuffer,
17754 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17755 match ordinal {
17756 ordinal => {
17757 handler.on_unknown_interaction(ordinal).await;
17758 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
17759 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17760 } else {
17761 Ok(())
17762 }
17763 }
17764 }
17765 }
17766}
17767
17768pub trait CapabilityStoreServerHandler<
17772 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17773 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17774>
17775{
17776 #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
17777 fn duplicate(
17778 &mut self,
17779
17780 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
17781
17782 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
17783 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17784
17785 #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
17786 fn drop(
17787 &mut self,
17788
17789 request: ::fidl_next::Request<capability_store::Drop, ___T>,
17790
17791 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
17792 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17793
17794 #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
17795 fn export(
17796 &mut self,
17797
17798 request: ::fidl_next::Request<capability_store::Export, ___T>,
17799
17800 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
17801 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17802
17803 #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
17804 fn import(
17805 &mut self,
17806
17807 request: ::fidl_next::Request<capability_store::Import, ___T>,
17808
17809 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
17810 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17811
17812 #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17813 fn connector_create(
17814 &mut self,
17815
17816 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
17817
17818 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
17819 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17820
17821 #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17822 fn connector_open(
17823 &mut self,
17824
17825 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
17826
17827 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
17828 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17829
17830 #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17831 fn dir_connector_create(
17832 &mut self,
17833
17834 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
17835
17836 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
17837 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17838
17839 #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
17840 fn dir_connector_open(
17841 &mut self,
17842
17843 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
17844
17845 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
17846 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17847
17848 #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
17849 fn dictionary_create(
17850 &mut self,
17851
17852 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
17853
17854 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
17855 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17856
17857 #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
17858 fn dictionary_legacy_import(
17859 &mut self,
17860
17861 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
17862
17863 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
17864 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17865
17866 #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
17867 fn dictionary_legacy_export(
17868 &mut self,
17869
17870 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
17871
17872 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
17873 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17874
17875 #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
17876 fn dictionary_insert(
17877 &mut self,
17878
17879 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
17880
17881 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
17882 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17883
17884 #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
17885 fn dictionary_get(
17886 &mut self,
17887
17888 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
17889
17890 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
17891 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17892
17893 #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
17894 fn dictionary_remove(
17895 &mut self,
17896
17897 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
17898
17899 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
17900 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17901
17902 #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
17903 fn dictionary_copy(
17904 &mut self,
17905
17906 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
17907
17908 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
17909 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17910
17911 #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17912 fn dictionary_keys(
17913 &mut self,
17914
17915 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
17916
17917 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
17918 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17919
17920 #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17921 fn dictionary_enumerate(
17922 &mut self,
17923
17924 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
17925
17926 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
17927 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17928
17929 #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
17930 fn dictionary_drain(
17931 &mut self,
17932
17933 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
17934
17935 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
17936 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17937
17938 fn on_unknown_interaction(
17939 &mut self,
17940 ordinal: u64,
17941 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17942 ::core::future::ready(())
17943 }
17944}
17945
17946impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
17947where
17948 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
17949 ___T: ::fidl_next::Transport,
17950 <capability_store::Duplicate as ::fidl_next::Method>::Request:
17951 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17952 <capability_store::Drop as ::fidl_next::Method>::Request:
17953 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17954 <capability_store::Export as ::fidl_next::Method>::Request:
17955 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17956 <capability_store::Import as ::fidl_next::Method>::Request:
17957 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17958 <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
17959 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17960 <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
17961 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17962 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
17963 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17964 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
17965 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17966 <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
17967 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17968 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
17969 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17970 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
17971 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17972 <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
17973 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17974 <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
17975 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17976 <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
17977 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17978 <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
17979 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17980 <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
17981 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17982 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
17983 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17984 <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
17985 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17986{
17987 async fn on_one_way(
17988 handler: &mut ___H,
17989 ordinal: u64,
17990 flexibility: ::fidl_next::protocol::Flexibility,
17991 buffer: ___T::RecvBuffer,
17992 ) -> ::core::result::Result<
17993 (),
17994 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17995 > {
17996 match ordinal {
17997 ordinal => {
17998 handler.on_unknown_interaction(ordinal).await;
17999 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18000 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18001 } else {
18002 Ok(())
18003 }
18004 }
18005 }
18006 }
18007
18008 async fn on_two_way(
18009 handler: &mut ___H,
18010 ordinal: u64,
18011 flexibility: ::fidl_next::protocol::Flexibility,
18012 buffer: ___T::RecvBuffer,
18013 responder: ::fidl_next::protocol::Responder<___T>,
18014 ) -> ::core::result::Result<
18015 (),
18016 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18017 > {
18018 match ordinal {
18019 6727592627741008260 => {
18020 let responder = ::fidl_next::Responder::from_untyped(responder);
18021
18022 match ::fidl_next::DecoderExt::decode(buffer) {
18023 Ok(decoded) => {
18024 handler.duplicate(decoded, responder).await;
18025 Ok(())
18026 }
18027 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18028 ordinal: 6727592627741008260,
18029 error,
18030 }),
18031 }
18032 }
18033
18034 753328233834620249 => {
18035 let responder = ::fidl_next::Responder::from_untyped(responder);
18036
18037 match ::fidl_next::DecoderExt::decode(buffer) {
18038 Ok(decoded) => {
18039 handler.drop(decoded, responder).await;
18040 Ok(())
18041 }
18042 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18043 ordinal: 753328233834620249,
18044 error,
18045 }),
18046 }
18047 }
18048
18049 226159162093533951 => {
18050 let responder = ::fidl_next::Responder::from_untyped(responder);
18051
18052 match ::fidl_next::DecoderExt::decode(buffer) {
18053 Ok(decoded) => {
18054 handler.export(decoded, responder).await;
18055 Ok(())
18056 }
18057 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18058 ordinal: 226159162093533951,
18059 error,
18060 }),
18061 }
18062 }
18063
18064 2276030276116435867 => {
18065 let responder = ::fidl_next::Responder::from_untyped(responder);
18066
18067 match ::fidl_next::DecoderExt::decode(buffer) {
18068 Ok(decoded) => {
18069 handler.import(decoded, responder).await;
18070 Ok(())
18071 }
18072 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18073 ordinal: 2276030276116435867,
18074 error,
18075 }),
18076 }
18077 }
18078
18079 2979461408102095909 => {
18080 let responder = ::fidl_next::Responder::from_untyped(responder);
18081
18082 match ::fidl_next::DecoderExt::decode(buffer) {
18083 Ok(decoded) => {
18084 handler.connector_create(decoded, responder).await;
18085 Ok(())
18086 }
18087 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18088 ordinal: 2979461408102095909,
18089 error,
18090 }),
18091 }
18092 }
18093
18094 6016362336453278623 => {
18095 let responder = ::fidl_next::Responder::from_untyped(responder);
18096
18097 match ::fidl_next::DecoderExt::decode(buffer) {
18098 Ok(decoded) => {
18099 handler.connector_open(decoded, responder).await;
18100 Ok(())
18101 }
18102 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18103 ordinal: 6016362336453278623,
18104 error,
18105 }),
18106 }
18107 }
18108
18109 1756747594275428795 => {
18110 let responder = ::fidl_next::Responder::from_untyped(responder);
18111
18112 match ::fidl_next::DecoderExt::decode(buffer) {
18113 Ok(decoded) => {
18114 handler.dir_connector_create(decoded, responder).await;
18115 Ok(())
18116 }
18117 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18118 ordinal: 1756747594275428795,
18119 error,
18120 }),
18121 }
18122 }
18123
18124 6219704004220369153 => {
18125 let responder = ::fidl_next::Responder::from_untyped(responder);
18126
18127 match ::fidl_next::DecoderExt::decode(buffer) {
18128 Ok(decoded) => {
18129 handler.dir_connector_open(decoded, responder).await;
18130 Ok(())
18131 }
18132 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18133 ordinal: 6219704004220369153,
18134 error,
18135 }),
18136 }
18137 }
18138
18139 7608770958894948499 => {
18140 let responder = ::fidl_next::Responder::from_untyped(responder);
18141
18142 match ::fidl_next::DecoderExt::decode(buffer) {
18143 Ok(decoded) => {
18144 handler.dictionary_create(decoded, responder).await;
18145 Ok(())
18146 }
18147 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18148 ordinal: 7608770958894948499,
18149 error,
18150 }),
18151 }
18152 }
18153
18154 8285893703432012383 => {
18155 let responder = ::fidl_next::Responder::from_untyped(responder);
18156
18157 match ::fidl_next::DecoderExt::decode(buffer) {
18158 Ok(decoded) => {
18159 handler.dictionary_legacy_import(decoded, responder).await;
18160 Ok(())
18161 }
18162 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18163 ordinal: 8285893703432012383,
18164 error,
18165 }),
18166 }
18167 }
18168
18169 4647175832683306445 => {
18170 let responder = ::fidl_next::Responder::from_untyped(responder);
18171
18172 match ::fidl_next::DecoderExt::decode(buffer) {
18173 Ok(decoded) => {
18174 handler.dictionary_legacy_export(decoded, responder).await;
18175 Ok(())
18176 }
18177 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18178 ordinal: 4647175832683306445,
18179 error,
18180 }),
18181 }
18182 }
18183
18184 8575443262986538023 => {
18185 let responder = ::fidl_next::Responder::from_untyped(responder);
18186
18187 match ::fidl_next::DecoderExt::decode(buffer) {
18188 Ok(decoded) => {
18189 handler.dictionary_insert(decoded, responder).await;
18190 Ok(())
18191 }
18192 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18193 ordinal: 8575443262986538023,
18194 error,
18195 }),
18196 }
18197 }
18198
18199 5592951026866236882 => {
18200 let responder = ::fidl_next::Responder::from_untyped(responder);
18201
18202 match ::fidl_next::DecoderExt::decode(buffer) {
18203 Ok(decoded) => {
18204 handler.dictionary_get(decoded, responder).await;
18205 Ok(())
18206 }
18207 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18208 ordinal: 5592951026866236882,
18209 error,
18210 }),
18211 }
18212 }
18213
18214 343892214579320051 => {
18215 let responder = ::fidl_next::Responder::from_untyped(responder);
18216
18217 match ::fidl_next::DecoderExt::decode(buffer) {
18218 Ok(decoded) => {
18219 handler.dictionary_remove(decoded, responder).await;
18220 Ok(())
18221 }
18222 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18223 ordinal: 343892214579320051,
18224 error,
18225 }),
18226 }
18227 }
18228
18229 3977783339739362383 => {
18230 let responder = ::fidl_next::Responder::from_untyped(responder);
18231
18232 match ::fidl_next::DecoderExt::decode(buffer) {
18233 Ok(decoded) => {
18234 handler.dictionary_copy(decoded, responder).await;
18235 Ok(())
18236 }
18237 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18238 ordinal: 3977783339739362383,
18239 error,
18240 }),
18241 }
18242 }
18243
18244 597577248872787102 => {
18245 let responder = ::fidl_next::Responder::from_untyped(responder);
18246
18247 match ::fidl_next::DecoderExt::decode(buffer) {
18248 Ok(decoded) => {
18249 handler.dictionary_keys(decoded, responder).await;
18250 Ok(())
18251 }
18252 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18253 ordinal: 597577248872787102,
18254 error,
18255 }),
18256 }
18257 }
18258
18259 964467096271472193 => {
18260 let responder = ::fidl_next::Responder::from_untyped(responder);
18261
18262 match ::fidl_next::DecoderExt::decode(buffer) {
18263 Ok(decoded) => {
18264 handler.dictionary_enumerate(decoded, responder).await;
18265 Ok(())
18266 }
18267 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18268 ordinal: 964467096271472193,
18269 error,
18270 }),
18271 }
18272 }
18273
18274 2928364469569621208 => {
18275 let responder = ::fidl_next::Responder::from_untyped(responder);
18276
18277 match ::fidl_next::DecoderExt::decode(buffer) {
18278 Ok(decoded) => {
18279 handler.dictionary_drain(decoded, responder).await;
18280 Ok(())
18281 }
18282 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18283 ordinal: 2928364469569621208,
18284 error,
18285 }),
18286 }
18287 }
18288
18289 ordinal => {
18290 handler.on_unknown_interaction(ordinal).await;
18291 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18292 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18293 } else {
18294 responder
18295 .respond(
18296 ordinal,
18297 flexibility,
18298 ::fidl_next::Flexible::<()>::FrameworkErr(
18299 ::fidl_next::FrameworkError::UnknownMethod,
18300 ),
18301 )
18302 .expect("encoding a framework error should never fail")
18303 .await?;
18304 Ok(())
18305 }
18306 }
18307 }
18308 }
18309}
18310
18311#[derive(PartialEq, Debug)]
18313pub struct ConnectorRouter;
18314
18315impl ::fidl_next::Discoverable for ConnectorRouter {
18316 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
18317}
18318
18319#[cfg(target_os = "fuchsia")]
18320impl ::fidl_next::HasTransport for ConnectorRouter {
18321 type Transport = ::fidl_next::fuchsia::zx::Channel;
18322}
18323
18324pub mod connector_router {
18325 pub mod prelude {
18326 pub use crate::{
18327 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
18328 connector_router,
18329 };
18330
18331 pub use crate::natural::ConnectorRouterRouteResponse;
18332
18333 pub use crate::natural::RouteRequest;
18334
18335 pub use crate::natural::RouterError;
18336 }
18337
18338 pub struct Route;
18339
18340 impl ::fidl_next::Method for Route {
18341 const ORDINAL: u64 = 8420527046218942310;
18342 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18343 ::fidl_next::protocol::Flexibility::Flexible;
18344
18345 type Protocol = crate::ConnectorRouter;
18346
18347 type Request = crate::wire::RouteRequest<'static>;
18348
18349 type Response = ::fidl_next::WireFlexibleResult<
18350 'static,
18351 crate::wire::ConnectorRouterRouteResponse,
18352 crate::wire::RouterError,
18353 >;
18354 }
18355
18356 impl<___R> ::fidl_next::Respond<___R> for Route {
18357 type Output = ::fidl_next::FlexibleResult<
18358 ___R,
18359 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
18360 >;
18361
18362 fn respond(response: ___R) -> Self::Output {
18363 ::fidl_next::FlexibleResult::Ok(response)
18364 }
18365 }
18366
18367 impl<___R> ::fidl_next::RespondErr<___R> for Route {
18368 type Output = ::fidl_next::FlexibleResult<
18369 ::fidl_next::util::EncodableNever<crate::wire::ConnectorRouterRouteResponse>,
18370 ___R,
18371 >;
18372
18373 fn respond_err(response: ___R) -> Self::Output {
18374 ::fidl_next::FlexibleResult::Err(response)
18375 }
18376 }
18377
18378 mod ___detail {
18379 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
18380 where
18381 ___T: ::fidl_next::Transport,
18382 {
18383 type Client = ConnectorRouterClient<___T>;
18384 type Server = ConnectorRouterServer<___T>;
18385 }
18386
18387 #[repr(transparent)]
18389 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
18390 #[allow(dead_code)]
18391 client: ::fidl_next::protocol::Client<___T>,
18392 }
18393
18394 impl<___T> ConnectorRouterClient<___T>
18395 where
18396 ___T: ::fidl_next::Transport,
18397 {
18398 pub fn route_with<___R>(
18399 &self,
18400 request: ___R,
18401 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
18402 where
18403 ___R: ::fidl_next::Encode<
18404 <___T as ::fidl_next::Transport>::SendBuffer,
18405 Encoded = crate::wire::RouteRequest<'static>,
18406 >,
18407 {
18408 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18409 8420527046218942310,
18410 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
18411 request,
18412 ))
18413 }
18414 }
18415
18416 #[repr(transparent)]
18418 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
18419 server: ::fidl_next::protocol::Server<___T>,
18420 }
18421
18422 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
18423 }
18424}
18425
18426pub trait ConnectorRouterClientHandler<
18430 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18431 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18432>
18433{
18434 fn on_unknown_interaction(
18435 &mut self,
18436 ordinal: u64,
18437 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18438 ::core::future::ready(())
18439 }
18440}
18441
18442impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
18443where
18444 ___T: ::fidl_next::Transport,
18445{
18446 async fn on_unknown_interaction(&mut self, _: u64) {}
18447}
18448
18449impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
18450where
18451 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
18452 ___T: ::fidl_next::Transport,
18453 <connector_router::Route as ::fidl_next::Method>::Response:
18454 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18455{
18456 async fn on_event(
18457 handler: &mut ___H,
18458 ordinal: u64,
18459 flexibility: ::fidl_next::protocol::Flexibility,
18460 buffer: ___T::RecvBuffer,
18461 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18462 match ordinal {
18463 ordinal => {
18464 handler.on_unknown_interaction(ordinal).await;
18465 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18466 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18467 } else {
18468 Ok(())
18469 }
18470 }
18471 }
18472 }
18473}
18474
18475pub trait ConnectorRouterServerHandler<
18479 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18480 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18481>
18482{
18483 fn route(
18484 &mut self,
18485
18486 request: ::fidl_next::Request<connector_router::Route, ___T>,
18487
18488 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
18489 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18490
18491 fn on_unknown_interaction(
18492 &mut self,
18493 ordinal: u64,
18494 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18495 ::core::future::ready(())
18496 }
18497}
18498
18499impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
18500where
18501 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
18502 ___T: ::fidl_next::Transport,
18503 <connector_router::Route as ::fidl_next::Method>::Request:
18504 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18505{
18506 async fn on_one_way(
18507 handler: &mut ___H,
18508 ordinal: u64,
18509 flexibility: ::fidl_next::protocol::Flexibility,
18510 buffer: ___T::RecvBuffer,
18511 ) -> ::core::result::Result<
18512 (),
18513 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18514 > {
18515 match ordinal {
18516 ordinal => {
18517 handler.on_unknown_interaction(ordinal).await;
18518 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18519 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18520 } else {
18521 Ok(())
18522 }
18523 }
18524 }
18525 }
18526
18527 async fn on_two_way(
18528 handler: &mut ___H,
18529 ordinal: u64,
18530 flexibility: ::fidl_next::protocol::Flexibility,
18531 buffer: ___T::RecvBuffer,
18532 responder: ::fidl_next::protocol::Responder<___T>,
18533 ) -> ::core::result::Result<
18534 (),
18535 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18536 > {
18537 match ordinal {
18538 8420527046218942310 => {
18539 let responder = ::fidl_next::Responder::from_untyped(responder);
18540
18541 match ::fidl_next::DecoderExt::decode(buffer) {
18542 Ok(decoded) => {
18543 handler.route(decoded, responder).await;
18544 Ok(())
18545 }
18546 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18547 ordinal: 8420527046218942310,
18548 error,
18549 }),
18550 }
18551 }
18552
18553 ordinal => {
18554 handler.on_unknown_interaction(ordinal).await;
18555 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18556 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18557 } else {
18558 responder
18559 .respond(
18560 ordinal,
18561 flexibility,
18562 ::fidl_next::Flexible::<()>::FrameworkErr(
18563 ::fidl_next::FrameworkError::UnknownMethod,
18564 ),
18565 )
18566 .expect("encoding a framework error should never fail")
18567 .await?;
18568 Ok(())
18569 }
18570 }
18571 }
18572 }
18573}
18574
18575#[derive(PartialEq, Debug)]
18577pub struct DataRouter;
18578
18579impl ::fidl_next::Discoverable for DataRouter {
18580 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
18581}
18582
18583#[cfg(target_os = "fuchsia")]
18584impl ::fidl_next::HasTransport for DataRouter {
18585 type Transport = ::fidl_next::fuchsia::zx::Channel;
18586}
18587
18588pub mod data_router {
18589 pub mod prelude {
18590 pub use crate::{
18591 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
18592 };
18593
18594 pub use crate::natural::DataRouterRouteResponse;
18595
18596 pub use crate::natural::RouteRequest;
18597
18598 pub use crate::natural::RouterError;
18599 }
18600
18601 pub struct Route;
18602
18603 impl ::fidl_next::Method for Route {
18604 const ORDINAL: u64 = 3352890635970754564;
18605 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18606 ::fidl_next::protocol::Flexibility::Flexible;
18607
18608 type Protocol = crate::DataRouter;
18609
18610 type Request = crate::wire::RouteRequest<'static>;
18611
18612 type Response = ::fidl_next::WireFlexibleResult<
18613 'static,
18614 crate::wire::DataRouterRouteResponse<'static>,
18615 crate::wire::RouterError,
18616 >;
18617 }
18618
18619 impl<___R> ::fidl_next::Respond<___R> for Route {
18620 type Output = ::fidl_next::FlexibleResult<
18621 ___R,
18622 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
18623 >;
18624
18625 fn respond(response: ___R) -> Self::Output {
18626 ::fidl_next::FlexibleResult::Ok(response)
18627 }
18628 }
18629
18630 impl<___R> ::fidl_next::RespondErr<___R> for Route {
18631 type Output = ::fidl_next::FlexibleResult<
18632 ::fidl_next::util::EncodableNever<crate::wire::DataRouterRouteResponse<'static>>,
18633 ___R,
18634 >;
18635
18636 fn respond_err(response: ___R) -> Self::Output {
18637 ::fidl_next::FlexibleResult::Err(response)
18638 }
18639 }
18640
18641 mod ___detail {
18642 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
18643 where
18644 ___T: ::fidl_next::Transport,
18645 {
18646 type Client = DataRouterClient<___T>;
18647 type Server = DataRouterServer<___T>;
18648 }
18649
18650 #[repr(transparent)]
18652 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
18653 #[allow(dead_code)]
18654 client: ::fidl_next::protocol::Client<___T>,
18655 }
18656
18657 impl<___T> DataRouterClient<___T>
18658 where
18659 ___T: ::fidl_next::Transport,
18660 {
18661 pub fn route_with<___R>(
18662 &self,
18663 request: ___R,
18664 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
18665 where
18666 ___R: ::fidl_next::Encode<
18667 <___T as ::fidl_next::Transport>::SendBuffer,
18668 Encoded = crate::wire::RouteRequest<'static>,
18669 >,
18670 {
18671 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18672 3352890635970754564,
18673 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
18674 request,
18675 ))
18676 }
18677 }
18678
18679 #[repr(transparent)]
18681 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
18682 server: ::fidl_next::protocol::Server<___T>,
18683 }
18684
18685 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
18686 }
18687}
18688
18689pub trait DataRouterClientHandler<
18693 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18694 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18695>
18696{
18697 fn on_unknown_interaction(
18698 &mut self,
18699 ordinal: u64,
18700 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18701 ::core::future::ready(())
18702 }
18703}
18704
18705impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
18706where
18707 ___T: ::fidl_next::Transport,
18708{
18709 async fn on_unknown_interaction(&mut self, _: u64) {}
18710}
18711
18712impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
18713where
18714 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
18715 ___T: ::fidl_next::Transport,
18716 <data_router::Route as ::fidl_next::Method>::Response:
18717 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18718{
18719 async fn on_event(
18720 handler: &mut ___H,
18721 ordinal: u64,
18722 flexibility: ::fidl_next::protocol::Flexibility,
18723 buffer: ___T::RecvBuffer,
18724 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18725 match ordinal {
18726 ordinal => {
18727 handler.on_unknown_interaction(ordinal).await;
18728 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18729 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18730 } else {
18731 Ok(())
18732 }
18733 }
18734 }
18735 }
18736}
18737
18738pub trait DataRouterServerHandler<
18742 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18743 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18744>
18745{
18746 fn route(
18747 &mut self,
18748
18749 request: ::fidl_next::Request<data_router::Route, ___T>,
18750
18751 responder: ::fidl_next::Responder<data_router::Route, ___T>,
18752 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18753
18754 fn on_unknown_interaction(
18755 &mut self,
18756 ordinal: u64,
18757 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18758 ::core::future::ready(())
18759 }
18760}
18761
18762impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
18763where
18764 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
18765 ___T: ::fidl_next::Transport,
18766 <data_router::Route as ::fidl_next::Method>::Request:
18767 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18768{
18769 async fn on_one_way(
18770 handler: &mut ___H,
18771 ordinal: u64,
18772 flexibility: ::fidl_next::protocol::Flexibility,
18773 buffer: ___T::RecvBuffer,
18774 ) -> ::core::result::Result<
18775 (),
18776 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18777 > {
18778 match ordinal {
18779 ordinal => {
18780 handler.on_unknown_interaction(ordinal).await;
18781 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18782 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18783 } else {
18784 Ok(())
18785 }
18786 }
18787 }
18788 }
18789
18790 async fn on_two_way(
18791 handler: &mut ___H,
18792 ordinal: u64,
18793 flexibility: ::fidl_next::protocol::Flexibility,
18794 buffer: ___T::RecvBuffer,
18795 responder: ::fidl_next::protocol::Responder<___T>,
18796 ) -> ::core::result::Result<
18797 (),
18798 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18799 > {
18800 match ordinal {
18801 3352890635970754564 => {
18802 let responder = ::fidl_next::Responder::from_untyped(responder);
18803
18804 match ::fidl_next::DecoderExt::decode(buffer) {
18805 Ok(decoded) => {
18806 handler.route(decoded, responder).await;
18807 Ok(())
18808 }
18809 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18810 ordinal: 3352890635970754564,
18811 error,
18812 }),
18813 }
18814 }
18815
18816 ordinal => {
18817 handler.on_unknown_interaction(ordinal).await;
18818 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18819 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18820 } else {
18821 responder
18822 .respond(
18823 ordinal,
18824 flexibility,
18825 ::fidl_next::Flexible::<()>::FrameworkErr(
18826 ::fidl_next::FrameworkError::UnknownMethod,
18827 ),
18828 )
18829 .expect("encoding a framework error should never fail")
18830 .await?;
18831 Ok(())
18832 }
18833 }
18834 }
18835 }
18836}
18837
18838#[derive(PartialEq, Debug)]
18840pub struct Dictionary;
18841
18842impl ::fidl_next::Discoverable for Dictionary {
18843 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
18844}
18845
18846#[cfg(target_os = "fuchsia")]
18847impl ::fidl_next::HasTransport for Dictionary {
18848 type Transport = ::fidl_next::fuchsia::zx::Channel;
18849}
18850
18851pub mod dictionary {
18852 pub mod prelude {
18853 pub use crate::{Dictionary, DictionaryClientHandler, DictionaryServerHandler, dictionary};
18854 }
18855
18856 mod ___detail {
18857 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Dictionary
18858 where
18859 ___T: ::fidl_next::Transport,
18860 {
18861 type Client = DictionaryClient<___T>;
18862 type Server = DictionaryServer<___T>;
18863 }
18864
18865 #[repr(transparent)]
18867 pub struct DictionaryClient<___T: ::fidl_next::Transport> {
18868 #[allow(dead_code)]
18869 client: ::fidl_next::protocol::Client<___T>,
18870 }
18871
18872 impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
18873
18874 #[repr(transparent)]
18876 pub struct DictionaryServer<___T: ::fidl_next::Transport> {
18877 server: ::fidl_next::protocol::Server<___T>,
18878 }
18879
18880 impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
18881 }
18882}
18883
18884pub trait DictionaryClientHandler<
18888 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18889 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18890>
18891{
18892 fn on_unknown_interaction(
18893 &mut self,
18894 ordinal: u64,
18895 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18896 ::core::future::ready(())
18897 }
18898}
18899
18900impl<___T> DictionaryClientHandler<___T> for ::fidl_next::IgnoreEvents
18901where
18902 ___T: ::fidl_next::Transport,
18903{
18904 async fn on_unknown_interaction(&mut self, _: u64) {}
18905}
18906
18907impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
18908where
18909 ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
18910 ___T: ::fidl_next::Transport,
18911{
18912 async fn on_event(
18913 handler: &mut ___H,
18914 ordinal: u64,
18915 flexibility: ::fidl_next::protocol::Flexibility,
18916 buffer: ___T::RecvBuffer,
18917 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18918 match ordinal {
18919 ordinal => {
18920 handler.on_unknown_interaction(ordinal).await;
18921 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18922 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18923 } else {
18924 Ok(())
18925 }
18926 }
18927 }
18928 }
18929}
18930
18931pub trait DictionaryServerHandler<
18935 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18936 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18937>
18938{
18939 fn on_unknown_interaction(
18940 &mut self,
18941 ordinal: u64,
18942 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18943 ::core::future::ready(())
18944 }
18945}
18946
18947impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
18948where
18949 ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
18950 ___T: ::fidl_next::Transport,
18951{
18952 async fn on_one_way(
18953 handler: &mut ___H,
18954 ordinal: u64,
18955 flexibility: ::fidl_next::protocol::Flexibility,
18956 buffer: ___T::RecvBuffer,
18957 ) -> ::core::result::Result<
18958 (),
18959 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18960 > {
18961 match ordinal {
18962 ordinal => {
18963 handler.on_unknown_interaction(ordinal).await;
18964 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18965 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18966 } else {
18967 Ok(())
18968 }
18969 }
18970 }
18971 }
18972
18973 async fn on_two_way(
18974 handler: &mut ___H,
18975 ordinal: u64,
18976 flexibility: ::fidl_next::protocol::Flexibility,
18977 buffer: ___T::RecvBuffer,
18978 responder: ::fidl_next::protocol::Responder<___T>,
18979 ) -> ::core::result::Result<
18980 (),
18981 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18982 > {
18983 match ordinal {
18984 ordinal => {
18985 handler.on_unknown_interaction(ordinal).await;
18986 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18987 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18988 } else {
18989 responder
18990 .respond(
18991 ordinal,
18992 flexibility,
18993 ::fidl_next::Flexible::<()>::FrameworkErr(
18994 ::fidl_next::FrameworkError::UnknownMethod,
18995 ),
18996 )
18997 .expect("encoding a framework error should never fail")
18998 .await?;
18999 Ok(())
19000 }
19001 }
19002 }
19003 }
19004}
19005
19006#[doc = " Maximum number of items returned by dictionary iterator.\n"]
19007pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;
19008
19009#[derive(PartialEq, Debug)]
19011pub struct DictionaryDrainIterator;
19012
19013#[cfg(target_os = "fuchsia")]
19014impl ::fidl_next::HasTransport for DictionaryDrainIterator {
19015 type Transport = ::fidl_next::fuchsia::zx::Channel;
19016}
19017
19018pub mod dictionary_drain_iterator {
19019 pub mod prelude {
19020 pub use crate::{
19021 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
19022 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
19023 };
19024
19025 pub use crate::natural::CapabilityStoreError;
19026
19027 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
19028
19029 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
19030 }
19031
19032 pub struct GetNext;
19033
19034 impl ::fidl_next::Method for GetNext {
19035 const ORDINAL: u64 = 5728722530628427873;
19036 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19037 ::fidl_next::protocol::Flexibility::Flexible;
19038
19039 type Protocol = crate::DictionaryDrainIterator;
19040
19041 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
19042
19043 type Response = ::fidl_next::WireFlexibleResult<
19044 'static,
19045 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
19046 crate::wire::CapabilityStoreError,
19047 >;
19048 }
19049
19050 impl<___R> ::fidl_next::Respond<___R> for GetNext {
19051 type Output = ::fidl_next::FlexibleResult<
19052 ___R,
19053 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
19054 >;
19055
19056 fn respond(response: ___R) -> Self::Output {
19057 ::fidl_next::FlexibleResult::Ok(response)
19058 }
19059 }
19060
19061 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
19062 type Output = ::fidl_next::FlexibleResult<
19063 ::fidl_next::util::EncodableNever<
19064 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
19065 >,
19066 ___R,
19067 >;
19068
19069 fn respond_err(response: ___R) -> Self::Output {
19070 ::fidl_next::FlexibleResult::Err(response)
19071 }
19072 }
19073
19074 mod ___detail {
19075 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
19076 where
19077 ___T: ::fidl_next::Transport,
19078 {
19079 type Client = DictionaryDrainIteratorClient<___T>;
19080 type Server = DictionaryDrainIteratorServer<___T>;
19081 }
19082
19083 #[repr(transparent)]
19085 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
19086 #[allow(dead_code)]
19087 client: ::fidl_next::protocol::Client<___T>,
19088 }
19089
19090 impl<___T> DictionaryDrainIteratorClient<___T>
19091 where
19092 ___T: ::fidl_next::Transport,
19093 {
19094 #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19095 pub fn get_next(
19096 &self,
19097
19098 start_id: impl ::fidl_next::Encode<
19099 <___T as ::fidl_next::Transport>::SendBuffer,
19100 Encoded = ::fidl_next::WireU64,
19101 >,
19102
19103 limit: impl ::fidl_next::Encode<
19104 <___T as ::fidl_next::Transport>::SendBuffer,
19105 Encoded = ::fidl_next::WireU32,
19106 >,
19107 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19108 where
19109 <___T as ::fidl_next::Transport>::SendBuffer:
19110 ::fidl_next::encoder::InternalHandleEncoder,
19111 {
19112 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
19113 start_id,
19114
19115 limit,
19116 })
19117 }
19118
19119 #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19120 pub fn get_next_with<___R>(
19121 &self,
19122 request: ___R,
19123 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19124 where
19125 ___R: ::fidl_next::Encode<
19126 <___T as ::fidl_next::Transport>::SendBuffer,
19127 Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest,
19128 >,
19129 {
19130 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19131 5728722530628427873,
19132 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19133 request,
19134 ))
19135 }
19136 }
19137
19138 #[repr(transparent)]
19140 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
19141 server: ::fidl_next::protocol::Server<___T>,
19142 }
19143
19144 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19145 }
19146}
19147
19148pub trait DictionaryDrainIteratorClientHandler<
19152 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19153 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19154>
19155{
19156 fn on_unknown_interaction(
19157 &mut self,
19158 ordinal: u64,
19159 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19160 ::core::future::ready(())
19161 }
19162}
19163
19164impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19165where
19166 ___T: ::fidl_next::Transport,
19167{
19168 async fn on_unknown_interaction(&mut self, _: u64) {}
19169}
19170
19171impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
19172where
19173 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
19174 ___T: ::fidl_next::Transport,
19175 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Response:
19176 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19177{
19178 async fn on_event(
19179 handler: &mut ___H,
19180 ordinal: u64,
19181 flexibility: ::fidl_next::protocol::Flexibility,
19182 buffer: ___T::RecvBuffer,
19183 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19184 match ordinal {
19185 ordinal => {
19186 handler.on_unknown_interaction(ordinal).await;
19187 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19188 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19189 } else {
19190 Ok(())
19191 }
19192 }
19193 }
19194 }
19195}
19196
19197pub trait DictionaryDrainIteratorServerHandler<
19201 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19202 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19203>
19204{
19205 #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19206 fn get_next(
19207 &mut self,
19208
19209 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
19210
19211 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
19212 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19213
19214 fn on_unknown_interaction(
19215 &mut self,
19216 ordinal: u64,
19217 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19218 ::core::future::ready(())
19219 }
19220}
19221
19222impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
19223where
19224 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
19225 ___T: ::fidl_next::Transport,
19226 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
19227 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19228{
19229 async fn on_one_way(
19230 handler: &mut ___H,
19231 ordinal: u64,
19232 flexibility: ::fidl_next::protocol::Flexibility,
19233 buffer: ___T::RecvBuffer,
19234 ) -> ::core::result::Result<
19235 (),
19236 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19237 > {
19238 match ordinal {
19239 ordinal => {
19240 handler.on_unknown_interaction(ordinal).await;
19241 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19242 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19243 } else {
19244 Ok(())
19245 }
19246 }
19247 }
19248 }
19249
19250 async fn on_two_way(
19251 handler: &mut ___H,
19252 ordinal: u64,
19253 flexibility: ::fidl_next::protocol::Flexibility,
19254 buffer: ___T::RecvBuffer,
19255 responder: ::fidl_next::protocol::Responder<___T>,
19256 ) -> ::core::result::Result<
19257 (),
19258 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19259 > {
19260 match ordinal {
19261 5728722530628427873 => {
19262 let responder = ::fidl_next::Responder::from_untyped(responder);
19263
19264 match ::fidl_next::DecoderExt::decode(buffer) {
19265 Ok(decoded) => {
19266 handler.get_next(decoded, responder).await;
19267 Ok(())
19268 }
19269 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19270 ordinal: 5728722530628427873,
19271 error,
19272 }),
19273 }
19274 }
19275
19276 ordinal => {
19277 handler.on_unknown_interaction(ordinal).await;
19278 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19279 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19280 } else {
19281 responder
19282 .respond(
19283 ordinal,
19284 flexibility,
19285 ::fidl_next::Flexible::<()>::FrameworkErr(
19286 ::fidl_next::FrameworkError::UnknownMethod,
19287 ),
19288 )
19289 .expect("encoding a framework error should never fail")
19290 .await?;
19291 Ok(())
19292 }
19293 }
19294 }
19295 }
19296}
19297
19298#[derive(PartialEq, Debug)]
19300pub struct DictionaryEnumerateIterator;
19301
19302#[cfg(target_os = "fuchsia")]
19303impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
19304 type Transport = ::fidl_next::fuchsia::zx::Channel;
19305}
19306
19307pub mod dictionary_enumerate_iterator {
19308 pub mod prelude {
19309 pub use crate::{
19310 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
19311 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
19312 };
19313
19314 pub use crate::natural::CapabilityStoreError;
19315
19316 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
19317
19318 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
19319 }
19320
19321 pub struct GetNext;
19322
19323 impl ::fidl_next::Method for GetNext {
19324 const ORDINAL: u64 = 1511164556663256527;
19325 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19326 ::fidl_next::protocol::Flexibility::Flexible;
19327
19328 type Protocol = crate::DictionaryEnumerateIterator;
19329
19330 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
19331
19332 type Response = ::fidl_next::WireFlexibleResult<
19333 'static,
19334 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
19335 crate::wire::CapabilityStoreError,
19336 >;
19337 }
19338
19339 impl<___R> ::fidl_next::Respond<___R> for GetNext {
19340 type Output = ::fidl_next::FlexibleResult<
19341 ___R,
19342 ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
19343 >;
19344
19345 fn respond(response: ___R) -> Self::Output {
19346 ::fidl_next::FlexibleResult::Ok(response)
19347 }
19348 }
19349
19350 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
19351 type Output = ::fidl_next::FlexibleResult<
19352 ::fidl_next::util::EncodableNever<
19353 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
19354 >,
19355 ___R,
19356 >;
19357
19358 fn respond_err(response: ___R) -> Self::Output {
19359 ::fidl_next::FlexibleResult::Err(response)
19360 }
19361 }
19362
19363 mod ___detail {
19364 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
19365 where
19366 ___T: ::fidl_next::Transport,
19367 {
19368 type Client = DictionaryEnumerateIteratorClient<___T>;
19369 type Server = DictionaryEnumerateIteratorServer<___T>;
19370 }
19371
19372 #[repr(transparent)]
19374 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
19375 #[allow(dead_code)]
19376 client: ::fidl_next::protocol::Client<___T>,
19377 }
19378
19379 impl<___T> DictionaryEnumerateIteratorClient<___T>
19380 where
19381 ___T: ::fidl_next::Transport,
19382 {
19383 #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19384 pub fn get_next(
19385 &self,
19386
19387 start_id: impl ::fidl_next::Encode<
19388 <___T as ::fidl_next::Transport>::SendBuffer,
19389 Encoded = ::fidl_next::WireU64,
19390 >,
19391
19392 limit: impl ::fidl_next::Encode<
19393 <___T as ::fidl_next::Transport>::SendBuffer,
19394 Encoded = ::fidl_next::WireU32,
19395 >,
19396 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19397 where
19398 <___T as ::fidl_next::Transport>::SendBuffer:
19399 ::fidl_next::encoder::InternalHandleEncoder,
19400 {
19401 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
19402 start_id,
19403
19404 limit,
19405 })
19406 }
19407
19408 #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19409 pub fn get_next_with<___R>(
19410 &self,
19411 request: ___R,
19412 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19413 where
19414 ___R: ::fidl_next::Encode<
19415 <___T as ::fidl_next::Transport>::SendBuffer,
19416 Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest,
19417 >,
19418 {
19419 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19420 1511164556663256527,
19421 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19422 request,
19423 ))
19424 }
19425 }
19426
19427 #[repr(transparent)]
19429 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
19430 server: ::fidl_next::protocol::Server<___T>,
19431 }
19432
19433 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19434 }
19435}
19436
19437pub trait DictionaryEnumerateIteratorClientHandler<
19441 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19442 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19443>
19444{
19445 fn on_unknown_interaction(
19446 &mut self,
19447 ordinal: u64,
19448 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19449 ::core::future::ready(())
19450 }
19451}
19452
19453impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19454where
19455 ___T: ::fidl_next::Transport,
19456{
19457 async fn on_unknown_interaction(&mut self, _: u64) {}
19458}
19459
19460impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
19461where
19462 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
19463 ___T: ::fidl_next::Transport,
19464 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Response:
19465 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19466{
19467 async fn on_event(
19468 handler: &mut ___H,
19469 ordinal: u64,
19470 flexibility: ::fidl_next::protocol::Flexibility,
19471 buffer: ___T::RecvBuffer,
19472 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19473 match ordinal {
19474 ordinal => {
19475 handler.on_unknown_interaction(ordinal).await;
19476 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19477 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19478 } else {
19479 Ok(())
19480 }
19481 }
19482 }
19483 }
19484}
19485
19486pub trait DictionaryEnumerateIteratorServerHandler<
19490 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19491 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19492>
19493{
19494 #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
19495 fn get_next(
19496 &mut self,
19497
19498 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
19499
19500 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
19501 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19502
19503 fn on_unknown_interaction(
19504 &mut self,
19505 ordinal: u64,
19506 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19507 ::core::future::ready(())
19508 }
19509}
19510
19511impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
19512where
19513 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
19514 ___T: ::fidl_next::Transport,
19515 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
19516 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19517{
19518 async fn on_one_way(
19519 handler: &mut ___H,
19520 ordinal: u64,
19521 flexibility: ::fidl_next::protocol::Flexibility,
19522 buffer: ___T::RecvBuffer,
19523 ) -> ::core::result::Result<
19524 (),
19525 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19526 > {
19527 match ordinal {
19528 ordinal => {
19529 handler.on_unknown_interaction(ordinal).await;
19530 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19531 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19532 } else {
19533 Ok(())
19534 }
19535 }
19536 }
19537 }
19538
19539 async fn on_two_way(
19540 handler: &mut ___H,
19541 ordinal: u64,
19542 flexibility: ::fidl_next::protocol::Flexibility,
19543 buffer: ___T::RecvBuffer,
19544 responder: ::fidl_next::protocol::Responder<___T>,
19545 ) -> ::core::result::Result<
19546 (),
19547 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19548 > {
19549 match ordinal {
19550 1511164556663256527 => {
19551 let responder = ::fidl_next::Responder::from_untyped(responder);
19552
19553 match ::fidl_next::DecoderExt::decode(buffer) {
19554 Ok(decoded) => {
19555 handler.get_next(decoded, responder).await;
19556 Ok(())
19557 }
19558 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19559 ordinal: 1511164556663256527,
19560 error,
19561 }),
19562 }
19563 }
19564
19565 ordinal => {
19566 handler.on_unknown_interaction(ordinal).await;
19567 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19568 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19569 } else {
19570 responder
19571 .respond(
19572 ordinal,
19573 flexibility,
19574 ::fidl_next::Flexible::<()>::FrameworkErr(
19575 ::fidl_next::FrameworkError::UnknownMethod,
19576 ),
19577 )
19578 .expect("encoding a framework error should never fail")
19579 .await?;
19580 Ok(())
19581 }
19582 }
19583 }
19584 }
19585}
19586
19587#[derive(PartialEq, Debug)]
19589pub struct DictionaryKeysIterator;
19590
19591#[cfg(target_os = "fuchsia")]
19592impl ::fidl_next::HasTransport for DictionaryKeysIterator {
19593 type Transport = ::fidl_next::fuchsia::zx::Channel;
19594}
19595
19596pub mod dictionary_keys_iterator {
19597 pub mod prelude {
19598 pub use crate::{
19599 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
19600 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
19601 };
19602
19603 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
19604 }
19605
19606 pub struct GetNext;
19607
19608 impl ::fidl_next::Method for GetNext {
19609 const ORDINAL: u64 = 4987781442555247955;
19610 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19611 ::fidl_next::protocol::Flexibility::Flexible;
19612
19613 type Protocol = crate::DictionaryKeysIterator;
19614
19615 type Request = ();
19616
19617 type Response = ::fidl_next::WireFlexible<
19618 'static,
19619 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
19620 >;
19621 }
19622
19623 impl<___R> ::fidl_next::Respond<___R> for GetNext {
19624 type Output =
19625 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
19626
19627 fn respond(response: ___R) -> Self::Output {
19628 ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
19629 keys: response,
19630 })
19631 }
19632 }
19633
19634 mod ___detail {
19635 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
19636 where
19637 ___T: ::fidl_next::Transport,
19638 {
19639 type Client = DictionaryKeysIteratorClient<___T>;
19640 type Server = DictionaryKeysIteratorServer<___T>;
19641 }
19642
19643 #[repr(transparent)]
19645 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
19646 #[allow(dead_code)]
19647 client: ::fidl_next::protocol::Client<___T>,
19648 }
19649
19650 impl<___T> DictionaryKeysIteratorClient<___T>
19651 where
19652 ___T: ::fidl_next::Transport,
19653 {
19654 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
19655 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19656 4987781442555247955,
19657 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19658 (),
19659 ))
19660 }
19661 }
19662
19663 #[repr(transparent)]
19665 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
19666 server: ::fidl_next::protocol::Server<___T>,
19667 }
19668
19669 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19670 }
19671}
19672
19673pub trait DictionaryKeysIteratorClientHandler<
19677 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19678 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19679>
19680{
19681 fn on_unknown_interaction(
19682 &mut self,
19683 ordinal: u64,
19684 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19685 ::core::future::ready(())
19686 }
19687}
19688
19689impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19690where
19691 ___T: ::fidl_next::Transport,
19692{
19693 async fn on_unknown_interaction(&mut self, _: u64) {}
19694}
19695
19696impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
19697where
19698 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
19699 ___T: ::fidl_next::Transport,
19700 <dictionary_keys_iterator::GetNext as ::fidl_next::Method>::Response:
19701 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19702{
19703 async fn on_event(
19704 handler: &mut ___H,
19705 ordinal: u64,
19706 flexibility: ::fidl_next::protocol::Flexibility,
19707 buffer: ___T::RecvBuffer,
19708 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19709 match ordinal {
19710 ordinal => {
19711 handler.on_unknown_interaction(ordinal).await;
19712 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19713 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19714 } else {
19715 Ok(())
19716 }
19717 }
19718 }
19719 }
19720}
19721
19722pub trait DictionaryKeysIteratorServerHandler<
19726 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19727 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19728>
19729{
19730 fn get_next(
19731 &mut self,
19732
19733 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
19734 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19735
19736 fn on_unknown_interaction(
19737 &mut self,
19738 ordinal: u64,
19739 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19740 ::core::future::ready(())
19741 }
19742}
19743
19744impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
19745where
19746 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
19747 ___T: ::fidl_next::Transport,
19748{
19749 async fn on_one_way(
19750 handler: &mut ___H,
19751 ordinal: u64,
19752 flexibility: ::fidl_next::protocol::Flexibility,
19753 buffer: ___T::RecvBuffer,
19754 ) -> ::core::result::Result<
19755 (),
19756 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19757 > {
19758 match ordinal {
19759 ordinal => {
19760 handler.on_unknown_interaction(ordinal).await;
19761 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19762 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19763 } else {
19764 Ok(())
19765 }
19766 }
19767 }
19768 }
19769
19770 async fn on_two_way(
19771 handler: &mut ___H,
19772 ordinal: u64,
19773 flexibility: ::fidl_next::protocol::Flexibility,
19774 buffer: ___T::RecvBuffer,
19775 responder: ::fidl_next::protocol::Responder<___T>,
19776 ) -> ::core::result::Result<
19777 (),
19778 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19779 > {
19780 match ordinal {
19781 4987781442555247955 => {
19782 let responder = ::fidl_next::Responder::from_untyped(responder);
19783
19784 handler.get_next(responder).await;
19785 Ok(())
19786 }
19787
19788 ordinal => {
19789 handler.on_unknown_interaction(ordinal).await;
19790 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19791 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19792 } else {
19793 responder
19794 .respond(
19795 ordinal,
19796 flexibility,
19797 ::fidl_next::Flexible::<()>::FrameworkErr(
19798 ::fidl_next::FrameworkError::UnknownMethod,
19799 ),
19800 )
19801 .expect("encoding a framework error should never fail")
19802 .await?;
19803 Ok(())
19804 }
19805 }
19806 }
19807 }
19808}
19809
19810#[derive(PartialEq, Debug)]
19812pub struct DictionaryRouter;
19813
19814impl ::fidl_next::Discoverable for DictionaryRouter {
19815 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
19816}
19817
19818#[cfg(target_os = "fuchsia")]
19819impl ::fidl_next::HasTransport for DictionaryRouter {
19820 type Transport = ::fidl_next::fuchsia::zx::Channel;
19821}
19822
19823pub mod dictionary_router {
19824 pub mod prelude {
19825 pub use crate::{
19826 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
19827 dictionary_router,
19828 };
19829
19830 pub use crate::natural::DictionaryRouterRouteResponse;
19831
19832 pub use crate::natural::RouteRequest;
19833
19834 pub use crate::natural::RouterError;
19835 }
19836
19837 pub struct Route;
19838
19839 impl ::fidl_next::Method for Route {
19840 const ORDINAL: u64 = 8164012099375978399;
19841 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19842 ::fidl_next::protocol::Flexibility::Flexible;
19843
19844 type Protocol = crate::DictionaryRouter;
19845
19846 type Request = crate::wire::RouteRequest<'static>;
19847
19848 type Response = ::fidl_next::WireFlexibleResult<
19849 'static,
19850 crate::wire::DictionaryRouterRouteResponse,
19851 crate::wire::RouterError,
19852 >;
19853 }
19854
19855 impl<___R> ::fidl_next::Respond<___R> for Route {
19856 type Output = ::fidl_next::FlexibleResult<
19857 ___R,
19858 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
19859 >;
19860
19861 fn respond(response: ___R) -> Self::Output {
19862 ::fidl_next::FlexibleResult::Ok(response)
19863 }
19864 }
19865
19866 impl<___R> ::fidl_next::RespondErr<___R> for Route {
19867 type Output = ::fidl_next::FlexibleResult<
19868 ::fidl_next::util::EncodableNever<crate::wire::DictionaryRouterRouteResponse>,
19869 ___R,
19870 >;
19871
19872 fn respond_err(response: ___R) -> Self::Output {
19873 ::fidl_next::FlexibleResult::Err(response)
19874 }
19875 }
19876
19877 mod ___detail {
19878 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
19879 where
19880 ___T: ::fidl_next::Transport,
19881 {
19882 type Client = DictionaryRouterClient<___T>;
19883 type Server = DictionaryRouterServer<___T>;
19884 }
19885
19886 #[repr(transparent)]
19888 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
19889 #[allow(dead_code)]
19890 client: ::fidl_next::protocol::Client<___T>,
19891 }
19892
19893 impl<___T> DictionaryRouterClient<___T>
19894 where
19895 ___T: ::fidl_next::Transport,
19896 {
19897 pub fn route_with<___R>(
19898 &self,
19899 request: ___R,
19900 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
19901 where
19902 ___R: ::fidl_next::Encode<
19903 <___T as ::fidl_next::Transport>::SendBuffer,
19904 Encoded = crate::wire::RouteRequest<'static>,
19905 >,
19906 {
19907 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19908 8164012099375978399,
19909 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
19910 request,
19911 ))
19912 }
19913 }
19914
19915 #[repr(transparent)]
19917 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
19918 server: ::fidl_next::protocol::Server<___T>,
19919 }
19920
19921 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
19922 }
19923}
19924
19925pub trait DictionaryRouterClientHandler<
19929 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19930 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19931>
19932{
19933 fn on_unknown_interaction(
19934 &mut self,
19935 ordinal: u64,
19936 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19937 ::core::future::ready(())
19938 }
19939}
19940
19941impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
19942where
19943 ___T: ::fidl_next::Transport,
19944{
19945 async fn on_unknown_interaction(&mut self, _: u64) {}
19946}
19947
19948impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
19949where
19950 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
19951 ___T: ::fidl_next::Transport,
19952 <dictionary_router::Route as ::fidl_next::Method>::Response:
19953 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19954{
19955 async fn on_event(
19956 handler: &mut ___H,
19957 ordinal: u64,
19958 flexibility: ::fidl_next::protocol::Flexibility,
19959 buffer: ___T::RecvBuffer,
19960 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19961 match ordinal {
19962 ordinal => {
19963 handler.on_unknown_interaction(ordinal).await;
19964 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19965 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19966 } else {
19967 Ok(())
19968 }
19969 }
19970 }
19971 }
19972}
19973
19974pub trait DictionaryRouterServerHandler<
19978 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19979 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19980>
19981{
19982 fn route(
19983 &mut self,
19984
19985 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
19986
19987 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
19988 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19989
19990 fn on_unknown_interaction(
19991 &mut self,
19992 ordinal: u64,
19993 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19994 ::core::future::ready(())
19995 }
19996}
19997
19998impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
19999where
20000 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
20001 ___T: ::fidl_next::Transport,
20002 <dictionary_router::Route as ::fidl_next::Method>::Request:
20003 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20004{
20005 async fn on_one_way(
20006 handler: &mut ___H,
20007 ordinal: u64,
20008 flexibility: ::fidl_next::protocol::Flexibility,
20009 buffer: ___T::RecvBuffer,
20010 ) -> ::core::result::Result<
20011 (),
20012 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20013 > {
20014 match ordinal {
20015 ordinal => {
20016 handler.on_unknown_interaction(ordinal).await;
20017 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20018 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20019 } else {
20020 Ok(())
20021 }
20022 }
20023 }
20024 }
20025
20026 async fn on_two_way(
20027 handler: &mut ___H,
20028 ordinal: u64,
20029 flexibility: ::fidl_next::protocol::Flexibility,
20030 buffer: ___T::RecvBuffer,
20031 responder: ::fidl_next::protocol::Responder<___T>,
20032 ) -> ::core::result::Result<
20033 (),
20034 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20035 > {
20036 match ordinal {
20037 8164012099375978399 => {
20038 let responder = ::fidl_next::Responder::from_untyped(responder);
20039
20040 match ::fidl_next::DecoderExt::decode(buffer) {
20041 Ok(decoded) => {
20042 handler.route(decoded, responder).await;
20043 Ok(())
20044 }
20045 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20046 ordinal: 8164012099375978399,
20047 error,
20048 }),
20049 }
20050 }
20051
20052 ordinal => {
20053 handler.on_unknown_interaction(ordinal).await;
20054 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20055 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20056 } else {
20057 responder
20058 .respond(
20059 ordinal,
20060 flexibility,
20061 ::fidl_next::Flexible::<()>::FrameworkErr(
20062 ::fidl_next::FrameworkError::UnknownMethod,
20063 ),
20064 )
20065 .expect("encoding a framework error should never fail")
20066 .await?;
20067 Ok(())
20068 }
20069 }
20070 }
20071 }
20072}
20073
20074#[derive(PartialEq, Debug)]
20076pub struct DirConnectorRouter;
20077
20078impl ::fidl_next::Discoverable for DirConnectorRouter {
20079 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
20080}
20081
20082#[cfg(target_os = "fuchsia")]
20083impl ::fidl_next::HasTransport for DirConnectorRouter {
20084 type Transport = ::fidl_next::fuchsia::zx::Channel;
20085}
20086
20087pub mod dir_connector_router {
20088 pub mod prelude {
20089 pub use crate::{
20090 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
20091 dir_connector_router,
20092 };
20093
20094 pub use crate::natural::DirConnectorRouterRouteResponse;
20095
20096 pub use crate::natural::RouteRequest;
20097
20098 pub use crate::natural::RouterError;
20099 }
20100
20101 pub struct Route;
20102
20103 impl ::fidl_next::Method for Route {
20104 const ORDINAL: u64 = 972231070188342848;
20105 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20106 ::fidl_next::protocol::Flexibility::Flexible;
20107
20108 type Protocol = crate::DirConnectorRouter;
20109
20110 type Request = crate::wire::RouteRequest<'static>;
20111
20112 type Response = ::fidl_next::WireFlexibleResult<
20113 'static,
20114 crate::wire::DirConnectorRouterRouteResponse,
20115 crate::wire::RouterError,
20116 >;
20117 }
20118
20119 impl<___R> ::fidl_next::Respond<___R> for Route {
20120 type Output = ::fidl_next::FlexibleResult<
20121 ___R,
20122 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20123 >;
20124
20125 fn respond(response: ___R) -> Self::Output {
20126 ::fidl_next::FlexibleResult::Ok(response)
20127 }
20128 }
20129
20130 impl<___R> ::fidl_next::RespondErr<___R> for Route {
20131 type Output = ::fidl_next::FlexibleResult<
20132 ::fidl_next::util::EncodableNever<crate::wire::DirConnectorRouterRouteResponse>,
20133 ___R,
20134 >;
20135
20136 fn respond_err(response: ___R) -> Self::Output {
20137 ::fidl_next::FlexibleResult::Err(response)
20138 }
20139 }
20140
20141 mod ___detail {
20142 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
20143 where
20144 ___T: ::fidl_next::Transport,
20145 {
20146 type Client = DirConnectorRouterClient<___T>;
20147 type Server = DirConnectorRouterServer<___T>;
20148 }
20149
20150 #[repr(transparent)]
20152 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
20153 #[allow(dead_code)]
20154 client: ::fidl_next::protocol::Client<___T>,
20155 }
20156
20157 impl<___T> DirConnectorRouterClient<___T>
20158 where
20159 ___T: ::fidl_next::Transport,
20160 {
20161 pub fn route_with<___R>(
20162 &self,
20163 request: ___R,
20164 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20165 where
20166 ___R: ::fidl_next::Encode<
20167 <___T as ::fidl_next::Transport>::SendBuffer,
20168 Encoded = crate::wire::RouteRequest<'static>,
20169 >,
20170 {
20171 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20172 972231070188342848,
20173 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20174 request,
20175 ))
20176 }
20177 }
20178
20179 #[repr(transparent)]
20181 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
20182 server: ::fidl_next::protocol::Server<___T>,
20183 }
20184
20185 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
20186 }
20187}
20188
20189pub trait DirConnectorRouterClientHandler<
20193 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20194 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20195>
20196{
20197 fn on_unknown_interaction(
20198 &mut self,
20199 ordinal: u64,
20200 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20201 ::core::future::ready(())
20202 }
20203}
20204
20205impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20206where
20207 ___T: ::fidl_next::Transport,
20208{
20209 async fn on_unknown_interaction(&mut self, _: u64) {}
20210}
20211
20212impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
20213where
20214 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
20215 ___T: ::fidl_next::Transport,
20216 <dir_connector_router::Route as ::fidl_next::Method>::Response:
20217 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20218{
20219 async fn on_event(
20220 handler: &mut ___H,
20221 ordinal: u64,
20222 flexibility: ::fidl_next::protocol::Flexibility,
20223 buffer: ___T::RecvBuffer,
20224 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20225 match ordinal {
20226 ordinal => {
20227 handler.on_unknown_interaction(ordinal).await;
20228 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20229 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20230 } else {
20231 Ok(())
20232 }
20233 }
20234 }
20235 }
20236}
20237
20238pub trait DirConnectorRouterServerHandler<
20242 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20243 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20244>
20245{
20246 fn route(
20247 &mut self,
20248
20249 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
20250
20251 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
20252 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20253
20254 fn on_unknown_interaction(
20255 &mut self,
20256 ordinal: u64,
20257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20258 ::core::future::ready(())
20259 }
20260}
20261
20262impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
20263where
20264 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
20265 ___T: ::fidl_next::Transport,
20266 <dir_connector_router::Route as ::fidl_next::Method>::Request:
20267 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20268{
20269 async fn on_one_way(
20270 handler: &mut ___H,
20271 ordinal: u64,
20272 flexibility: ::fidl_next::protocol::Flexibility,
20273 buffer: ___T::RecvBuffer,
20274 ) -> ::core::result::Result<
20275 (),
20276 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20277 > {
20278 match ordinal {
20279 ordinal => {
20280 handler.on_unknown_interaction(ordinal).await;
20281 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20282 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20283 } else {
20284 Ok(())
20285 }
20286 }
20287 }
20288 }
20289
20290 async fn on_two_way(
20291 handler: &mut ___H,
20292 ordinal: u64,
20293 flexibility: ::fidl_next::protocol::Flexibility,
20294 buffer: ___T::RecvBuffer,
20295 responder: ::fidl_next::protocol::Responder<___T>,
20296 ) -> ::core::result::Result<
20297 (),
20298 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20299 > {
20300 match ordinal {
20301 972231070188342848 => {
20302 let responder = ::fidl_next::Responder::from_untyped(responder);
20303
20304 match ::fidl_next::DecoderExt::decode(buffer) {
20305 Ok(decoded) => {
20306 handler.route(decoded, responder).await;
20307 Ok(())
20308 }
20309 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20310 ordinal: 972231070188342848,
20311 error,
20312 }),
20313 }
20314 }
20315
20316 ordinal => {
20317 handler.on_unknown_interaction(ordinal).await;
20318 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20319 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20320 } else {
20321 responder
20322 .respond(
20323 ordinal,
20324 flexibility,
20325 ::fidl_next::Flexible::<()>::FrameworkErr(
20326 ::fidl_next::FrameworkError::UnknownMethod,
20327 ),
20328 )
20329 .expect("encoding a framework error should never fail")
20330 .await?;
20331 Ok(())
20332 }
20333 }
20334 }
20335 }
20336}
20337
20338#[derive(PartialEq, Debug)]
20340pub struct DirEntryRouter;
20341
20342impl ::fidl_next::Discoverable for DirEntryRouter {
20343 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
20344}
20345
20346#[cfg(target_os = "fuchsia")]
20347impl ::fidl_next::HasTransport for DirEntryRouter {
20348 type Transport = ::fidl_next::fuchsia::zx::Channel;
20349}
20350
20351pub mod dir_entry_router {
20352 pub mod prelude {
20353 pub use crate::{
20354 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
20355 dir_entry_router,
20356 };
20357
20358 pub use crate::natural::DirEntryRouterRouteResponse;
20359
20360 pub use crate::natural::RouteRequest;
20361
20362 pub use crate::natural::RouterError;
20363 }
20364
20365 pub struct Route;
20366
20367 impl ::fidl_next::Method for Route {
20368 const ORDINAL: u64 = 1929392218567642066;
20369 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20370 ::fidl_next::protocol::Flexibility::Flexible;
20371
20372 type Protocol = crate::DirEntryRouter;
20373
20374 type Request = crate::wire::RouteRequest<'static>;
20375
20376 type Response = ::fidl_next::WireFlexibleResult<
20377 'static,
20378 crate::wire::DirEntryRouterRouteResponse,
20379 crate::wire::RouterError,
20380 >;
20381 }
20382
20383 impl<___R> ::fidl_next::Respond<___R> for Route {
20384 type Output = ::fidl_next::FlexibleResult<
20385 ___R,
20386 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20387 >;
20388
20389 fn respond(response: ___R) -> Self::Output {
20390 ::fidl_next::FlexibleResult::Ok(response)
20391 }
20392 }
20393
20394 impl<___R> ::fidl_next::RespondErr<___R> for Route {
20395 type Output = ::fidl_next::FlexibleResult<
20396 ::fidl_next::util::EncodableNever<crate::wire::DirEntryRouterRouteResponse>,
20397 ___R,
20398 >;
20399
20400 fn respond_err(response: ___R) -> Self::Output {
20401 ::fidl_next::FlexibleResult::Err(response)
20402 }
20403 }
20404
20405 mod ___detail {
20406 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
20407 where
20408 ___T: ::fidl_next::Transport,
20409 {
20410 type Client = DirEntryRouterClient<___T>;
20411 type Server = DirEntryRouterServer<___T>;
20412 }
20413
20414 #[repr(transparent)]
20416 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
20417 #[allow(dead_code)]
20418 client: ::fidl_next::protocol::Client<___T>,
20419 }
20420
20421 impl<___T> DirEntryRouterClient<___T>
20422 where
20423 ___T: ::fidl_next::Transport,
20424 {
20425 pub fn route_with<___R>(
20426 &self,
20427 request: ___R,
20428 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20429 where
20430 ___R: ::fidl_next::Encode<
20431 <___T as ::fidl_next::Transport>::SendBuffer,
20432 Encoded = crate::wire::RouteRequest<'static>,
20433 >,
20434 {
20435 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20436 1929392218567642066,
20437 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20438 request,
20439 ))
20440 }
20441 }
20442
20443 #[repr(transparent)]
20445 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
20446 server: ::fidl_next::protocol::Server<___T>,
20447 }
20448
20449 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
20450 }
20451}
20452
20453pub trait DirEntryRouterClientHandler<
20457 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20458 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20459>
20460{
20461 fn on_unknown_interaction(
20462 &mut self,
20463 ordinal: u64,
20464 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20465 ::core::future::ready(())
20466 }
20467}
20468
20469impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20470where
20471 ___T: ::fidl_next::Transport,
20472{
20473 async fn on_unknown_interaction(&mut self, _: u64) {}
20474}
20475
20476impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
20477where
20478 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
20479 ___T: ::fidl_next::Transport,
20480 <dir_entry_router::Route as ::fidl_next::Method>::Response:
20481 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20482{
20483 async fn on_event(
20484 handler: &mut ___H,
20485 ordinal: u64,
20486 flexibility: ::fidl_next::protocol::Flexibility,
20487 buffer: ___T::RecvBuffer,
20488 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20489 match ordinal {
20490 ordinal => {
20491 handler.on_unknown_interaction(ordinal).await;
20492 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20493 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20494 } else {
20495 Ok(())
20496 }
20497 }
20498 }
20499 }
20500}
20501
20502pub trait DirEntryRouterServerHandler<
20506 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20507 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20508>
20509{
20510 fn route(
20511 &mut self,
20512
20513 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
20514
20515 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
20516 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20517
20518 fn on_unknown_interaction(
20519 &mut self,
20520 ordinal: u64,
20521 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20522 ::core::future::ready(())
20523 }
20524}
20525
20526impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
20527where
20528 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
20529 ___T: ::fidl_next::Transport,
20530 <dir_entry_router::Route as ::fidl_next::Method>::Request:
20531 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20532{
20533 async fn on_one_way(
20534 handler: &mut ___H,
20535 ordinal: u64,
20536 flexibility: ::fidl_next::protocol::Flexibility,
20537 buffer: ___T::RecvBuffer,
20538 ) -> ::core::result::Result<
20539 (),
20540 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20541 > {
20542 match ordinal {
20543 ordinal => {
20544 handler.on_unknown_interaction(ordinal).await;
20545 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20546 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20547 } else {
20548 Ok(())
20549 }
20550 }
20551 }
20552 }
20553
20554 async fn on_two_way(
20555 handler: &mut ___H,
20556 ordinal: u64,
20557 flexibility: ::fidl_next::protocol::Flexibility,
20558 buffer: ___T::RecvBuffer,
20559 responder: ::fidl_next::protocol::Responder<___T>,
20560 ) -> ::core::result::Result<
20561 (),
20562 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20563 > {
20564 match ordinal {
20565 1929392218567642066 => {
20566 let responder = ::fidl_next::Responder::from_untyped(responder);
20567
20568 match ::fidl_next::DecoderExt::decode(buffer) {
20569 Ok(decoded) => {
20570 handler.route(decoded, responder).await;
20571 Ok(())
20572 }
20573 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20574 ordinal: 1929392218567642066,
20575 error,
20576 }),
20577 }
20578 }
20579
20580 ordinal => {
20581 handler.on_unknown_interaction(ordinal).await;
20582 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20583 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20584 } else {
20585 responder
20586 .respond(
20587 ordinal,
20588 flexibility,
20589 ::fidl_next::Flexible::<()>::FrameworkErr(
20590 ::fidl_next::FrameworkError::UnknownMethod,
20591 ),
20592 )
20593 .expect("encoding a framework error should never fail")
20594 .await?;
20595 Ok(())
20596 }
20597 }
20598 }
20599 }
20600}
20601
20602#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
20604#[derive(PartialEq, Debug)]
20605pub struct DirReceiver;
20606
20607impl ::fidl_next::Discoverable for DirReceiver {
20608 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
20609}
20610
20611#[cfg(target_os = "fuchsia")]
20612impl ::fidl_next::HasTransport for DirReceiver {
20613 type Transport = ::fidl_next::fuchsia::zx::Channel;
20614}
20615
20616pub mod dir_receiver {
20617 pub mod prelude {
20618 pub use crate::{
20619 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
20620 };
20621
20622 pub use crate::natural::DirReceiverReceiveRequest;
20623 }
20624
20625 pub struct Receive;
20626
20627 impl ::fidl_next::Method for Receive {
20628 const ORDINAL: u64 = 926684461087488948;
20629 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20630 ::fidl_next::protocol::Flexibility::Flexible;
20631
20632 type Protocol = crate::DirReceiver;
20633
20634 type Request = crate::wire::DirReceiverReceiveRequest;
20635
20636 type Response = ::fidl_next::util::Never;
20637 }
20638
20639 mod ___detail {
20640 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
20641 where
20642 ___T: ::fidl_next::Transport,
20643 {
20644 type Client = DirReceiverClient<___T>;
20645 type Server = DirReceiverServer<___T>;
20646 }
20647
20648 #[repr(transparent)]
20650 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
20651 #[allow(dead_code)]
20652 client: ::fidl_next::protocol::Client<___T>,
20653 }
20654
20655 impl<___T> DirReceiverClient<___T>
20656 where
20657 ___T: ::fidl_next::Transport,
20658 {
20659 #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
20660 pub fn receive(
20661 &self,
20662
20663 channel: impl ::fidl_next::Encode<
20664 <___T as ::fidl_next::Transport>::SendBuffer,
20665 Encoded = ::fidl_next::ServerEnd<
20666 ::fidl_next_fuchsia_io::Directory,
20667 ::fidl_next::fuchsia::WireChannel,
20668 >,
20669 >,
20670 ) -> ::fidl_next::SendFuture<'_, ___T>
20671 where
20672 <___T as ::fidl_next::Transport>::SendBuffer:
20673 ::fidl_next::encoder::InternalHandleEncoder,
20674 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
20675 {
20676 self.receive_with(crate::generic::DirReceiverReceiveRequest { channel })
20677 }
20678
20679 #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
20680 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
20681 where
20682 ___R: ::fidl_next::Encode<
20683 <___T as ::fidl_next::Transport>::SendBuffer,
20684 Encoded = crate::wire::DirReceiverReceiveRequest,
20685 >,
20686 {
20687 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
20688 926684461087488948,
20689 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
20690 request,
20691 ))
20692 }
20693 }
20694
20695 #[repr(transparent)]
20697 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
20698 server: ::fidl_next::protocol::Server<___T>,
20699 }
20700
20701 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
20702 }
20703}
20704
20705pub trait DirReceiverClientHandler<
20709 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20710 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20711>
20712{
20713 fn on_unknown_interaction(
20714 &mut self,
20715 ordinal: u64,
20716 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20717 ::core::future::ready(())
20718 }
20719}
20720
20721impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
20722where
20723 ___T: ::fidl_next::Transport,
20724{
20725 async fn on_unknown_interaction(&mut self, _: u64) {}
20726}
20727
20728impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
20729where
20730 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
20731 ___T: ::fidl_next::Transport,
20732{
20733 async fn on_event(
20734 handler: &mut ___H,
20735 ordinal: u64,
20736 flexibility: ::fidl_next::protocol::Flexibility,
20737 buffer: ___T::RecvBuffer,
20738 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20739 match ordinal {
20740 ordinal => {
20741 handler.on_unknown_interaction(ordinal).await;
20742 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20743 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20744 } else {
20745 Ok(())
20746 }
20747 }
20748 }
20749 }
20750}
20751
20752pub trait DirReceiverServerHandler<
20756 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20757 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20758>
20759{
20760 #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
20761 fn receive(
20762 &mut self,
20763
20764 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
20765 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20766
20767 fn on_unknown_interaction(
20768 &mut self,
20769 ordinal: u64,
20770 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20771 ::core::future::ready(())
20772 }
20773}
20774
20775impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
20776where
20777 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
20778 ___T: ::fidl_next::Transport,
20779 <dir_receiver::Receive as ::fidl_next::Method>::Request:
20780 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20781{
20782 async fn on_one_way(
20783 handler: &mut ___H,
20784 ordinal: u64,
20785 flexibility: ::fidl_next::protocol::Flexibility,
20786 buffer: ___T::RecvBuffer,
20787 ) -> ::core::result::Result<
20788 (),
20789 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20790 > {
20791 match ordinal {
20792 926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
20793 Ok(decoded) => {
20794 handler.receive(decoded).await;
20795 Ok(())
20796 }
20797 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20798 ordinal: 926684461087488948,
20799 error,
20800 }),
20801 },
20802
20803 ordinal => {
20804 handler.on_unknown_interaction(ordinal).await;
20805 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20806 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20807 } else {
20808 Ok(())
20809 }
20810 }
20811 }
20812 }
20813
20814 async fn on_two_way(
20815 handler: &mut ___H,
20816 ordinal: u64,
20817 flexibility: ::fidl_next::protocol::Flexibility,
20818 buffer: ___T::RecvBuffer,
20819 responder: ::fidl_next::protocol::Responder<___T>,
20820 ) -> ::core::result::Result<
20821 (),
20822 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20823 > {
20824 match ordinal {
20825 ordinal => {
20826 handler.on_unknown_interaction(ordinal).await;
20827 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20828 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20829 } else {
20830 responder
20831 .respond(
20832 ordinal,
20833 flexibility,
20834 ::fidl_next::Flexible::<()>::FrameworkErr(
20835 ::fidl_next::FrameworkError::UnknownMethod,
20836 ),
20837 )
20838 .expect("encoding a framework error should never fail")
20839 .await?;
20840 Ok(())
20841 }
20842 }
20843 }
20844 }
20845}
20846
20847#[derive(PartialEq, Debug)]
20849pub struct DirectoryRouter;
20850
20851impl ::fidl_next::Discoverable for DirectoryRouter {
20852 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
20853}
20854
20855#[cfg(target_os = "fuchsia")]
20856impl ::fidl_next::HasTransport for DirectoryRouter {
20857 type Transport = ::fidl_next::fuchsia::zx::Channel;
20858}
20859
20860pub mod directory_router {
20861 pub mod prelude {
20862 pub use crate::{
20863 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
20864 directory_router,
20865 };
20866
20867 pub use crate::natural::DirectoryRouterRouteResponse;
20868
20869 pub use crate::natural::RouteRequest;
20870
20871 pub use crate::natural::RouterError;
20872 }
20873
20874 pub struct Route;
20875
20876 impl ::fidl_next::Method for Route {
20877 const ORDINAL: u64 = 7510716014181158689;
20878 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20879 ::fidl_next::protocol::Flexibility::Flexible;
20880
20881 type Protocol = crate::DirectoryRouter;
20882
20883 type Request = crate::wire::RouteRequest<'static>;
20884
20885 type Response = ::fidl_next::WireFlexibleResult<
20886 'static,
20887 crate::wire::DirectoryRouterRouteResponse,
20888 crate::wire::RouterError,
20889 >;
20890 }
20891
20892 impl<___R> ::fidl_next::Respond<___R> for Route {
20893 type Output = ::fidl_next::FlexibleResult<
20894 ___R,
20895 ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20896 >;
20897
20898 fn respond(response: ___R) -> Self::Output {
20899 ::fidl_next::FlexibleResult::Ok(response)
20900 }
20901 }
20902
20903 impl<___R> ::fidl_next::RespondErr<___R> for Route {
20904 type Output = ::fidl_next::FlexibleResult<
20905 ::fidl_next::util::EncodableNever<crate::wire::DirectoryRouterRouteResponse>,
20906 ___R,
20907 >;
20908
20909 fn respond_err(response: ___R) -> Self::Output {
20910 ::fidl_next::FlexibleResult::Err(response)
20911 }
20912 }
20913
20914 mod ___detail {
20915 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
20916 where
20917 ___T: ::fidl_next::Transport,
20918 {
20919 type Client = DirectoryRouterClient<___T>;
20920 type Server = DirectoryRouterServer<___T>;
20921 }
20922
20923 #[repr(transparent)]
20925 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
20926 #[allow(dead_code)]
20927 client: ::fidl_next::protocol::Client<___T>,
20928 }
20929
20930 impl<___T> DirectoryRouterClient<___T>
20931 where
20932 ___T: ::fidl_next::Transport,
20933 {
20934 pub fn route_with<___R>(
20935 &self,
20936 request: ___R,
20937 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20938 where
20939 ___R: ::fidl_next::Encode<
20940 <___T as ::fidl_next::Transport>::SendBuffer,
20941 Encoded = crate::wire::RouteRequest<'static>,
20942 >,
20943 {
20944 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20945 7510716014181158689,
20946 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20947 request,
20948 ))
20949 }
20950 }
20951
20952 #[repr(transparent)]
20954 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
20955 server: ::fidl_next::protocol::Server<___T>,
20956 }
20957
20958 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
20959 }
20960}
20961
20962pub trait DirectoryRouterClientHandler<
20966 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20967 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20968>
20969{
20970 fn on_unknown_interaction(
20971 &mut self,
20972 ordinal: u64,
20973 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20974 ::core::future::ready(())
20975 }
20976}
20977
20978impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20979where
20980 ___T: ::fidl_next::Transport,
20981{
20982 async fn on_unknown_interaction(&mut self, _: u64) {}
20983}
20984
20985impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
20986where
20987 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
20988 ___T: ::fidl_next::Transport,
20989 <directory_router::Route as ::fidl_next::Method>::Response:
20990 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20991{
20992 async fn on_event(
20993 handler: &mut ___H,
20994 ordinal: u64,
20995 flexibility: ::fidl_next::protocol::Flexibility,
20996 buffer: ___T::RecvBuffer,
20997 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20998 match ordinal {
20999 ordinal => {
21000 handler.on_unknown_interaction(ordinal).await;
21001 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21002 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21003 } else {
21004 Ok(())
21005 }
21006 }
21007 }
21008 }
21009}
21010
21011pub trait DirectoryRouterServerHandler<
21015 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21016 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21017>
21018{
21019 fn route(
21020 &mut self,
21021
21022 request: ::fidl_next::Request<directory_router::Route, ___T>,
21023
21024 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
21025 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21026
21027 fn on_unknown_interaction(
21028 &mut self,
21029 ordinal: u64,
21030 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21031 ::core::future::ready(())
21032 }
21033}
21034
21035impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
21036where
21037 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
21038 ___T: ::fidl_next::Transport,
21039 <directory_router::Route as ::fidl_next::Method>::Request:
21040 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
21041{
21042 async fn on_one_way(
21043 handler: &mut ___H,
21044 ordinal: u64,
21045 flexibility: ::fidl_next::protocol::Flexibility,
21046 buffer: ___T::RecvBuffer,
21047 ) -> ::core::result::Result<
21048 (),
21049 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21050 > {
21051 match ordinal {
21052 ordinal => {
21053 handler.on_unknown_interaction(ordinal).await;
21054 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21055 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21056 } else {
21057 Ok(())
21058 }
21059 }
21060 }
21061 }
21062
21063 async fn on_two_way(
21064 handler: &mut ___H,
21065 ordinal: u64,
21066 flexibility: ::fidl_next::protocol::Flexibility,
21067 buffer: ___T::RecvBuffer,
21068 responder: ::fidl_next::protocol::Responder<___T>,
21069 ) -> ::core::result::Result<
21070 (),
21071 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21072 > {
21073 match ordinal {
21074 7510716014181158689 => {
21075 let responder = ::fidl_next::Responder::from_untyped(responder);
21076
21077 match ::fidl_next::DecoderExt::decode(buffer) {
21078 Ok(decoded) => {
21079 handler.route(decoded, responder).await;
21080 Ok(())
21081 }
21082 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21083 ordinal: 7510716014181158689,
21084 error,
21085 }),
21086 }
21087 }
21088
21089 ordinal => {
21090 handler.on_unknown_interaction(ordinal).await;
21091 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21092 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21093 } else {
21094 responder
21095 .respond(
21096 ordinal,
21097 flexibility,
21098 ::fidl_next::Flexible::<()>::FrameworkErr(
21099 ::fidl_next::FrameworkError::UnknownMethod,
21100 ),
21101 )
21102 .expect("encoding a framework error should never fail")
21103 .await?;
21104 Ok(())
21105 }
21106 }
21107 }
21108 }
21109}
21110
21111#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
21113#[derive(PartialEq, Debug)]
21114pub struct Receiver;
21115
21116impl ::fidl_next::Discoverable for Receiver {
21117 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
21118}
21119
21120#[cfg(target_os = "fuchsia")]
21121impl ::fidl_next::HasTransport for Receiver {
21122 type Transport = ::fidl_next::fuchsia::zx::Channel;
21123}
21124
21125pub mod receiver {
21126 pub mod prelude {
21127 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
21128
21129 pub use crate::natural::ProtocolPayload;
21130 }
21131
21132 pub struct Receive;
21133
21134 impl ::fidl_next::Method for Receive {
21135 const ORDINAL: u64 = 340832707723008660;
21136 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
21137 ::fidl_next::protocol::Flexibility::Flexible;
21138
21139 type Protocol = crate::Receiver;
21140
21141 type Request = crate::wire::ProtocolPayload;
21142
21143 type Response = ::fidl_next::util::Never;
21144 }
21145
21146 mod ___detail {
21147 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
21148 where
21149 ___T: ::fidl_next::Transport,
21150 {
21151 type Client = ReceiverClient<___T>;
21152 type Server = ReceiverServer<___T>;
21153 }
21154
21155 #[repr(transparent)]
21157 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
21158 #[allow(dead_code)]
21159 client: ::fidl_next::protocol::Client<___T>,
21160 }
21161
21162 impl<___T> ReceiverClient<___T>
21163 where
21164 ___T: ::fidl_next::Transport,
21165 {
21166 #[doc = " Sends a channel to this receiver.\n"]
21167 pub fn receive(
21168 &self,
21169
21170 channel: impl ::fidl_next::Encode<
21171 <___T as ::fidl_next::Transport>::SendBuffer,
21172 Encoded = ::fidl_next::fuchsia::WireChannel,
21173 >,
21174 ) -> ::fidl_next::SendFuture<'_, ___T>
21175 where
21176 <___T as ::fidl_next::Transport>::SendBuffer:
21177 ::fidl_next::encoder::InternalHandleEncoder,
21178 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
21179 {
21180 self.receive_with(crate::generic::ProtocolPayload { channel })
21181 }
21182
21183 #[doc = " Sends a channel to this receiver.\n"]
21184 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
21185 where
21186 ___R: ::fidl_next::Encode<
21187 <___T as ::fidl_next::Transport>::SendBuffer,
21188 Encoded = crate::wire::ProtocolPayload,
21189 >,
21190 {
21191 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
21192 340832707723008660,
21193 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
21194 request,
21195 ))
21196 }
21197 }
21198
21199 #[repr(transparent)]
21201 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
21202 server: ::fidl_next::protocol::Server<___T>,
21203 }
21204
21205 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
21206 }
21207}
21208
21209pub trait ReceiverClientHandler<
21213 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21214 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21215>
21216{
21217 fn on_unknown_interaction(
21218 &mut self,
21219 ordinal: u64,
21220 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21221 ::core::future::ready(())
21222 }
21223}
21224
21225impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
21226where
21227 ___T: ::fidl_next::Transport,
21228{
21229 async fn on_unknown_interaction(&mut self, _: u64) {}
21230}
21231
21232impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
21233where
21234 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
21235 ___T: ::fidl_next::Transport,
21236{
21237 async fn on_event(
21238 handler: &mut ___H,
21239 ordinal: u64,
21240 flexibility: ::fidl_next::protocol::Flexibility,
21241 buffer: ___T::RecvBuffer,
21242 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21243 match ordinal {
21244 ordinal => {
21245 handler.on_unknown_interaction(ordinal).await;
21246 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21247 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21248 } else {
21249 Ok(())
21250 }
21251 }
21252 }
21253 }
21254}
21255
21256pub trait ReceiverServerHandler<
21260 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21261 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21262>
21263{
21264 #[doc = " Sends a channel to this receiver.\n"]
21265 fn receive(
21266 &mut self,
21267
21268 request: ::fidl_next::Request<receiver::Receive, ___T>,
21269 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21270
21271 fn on_unknown_interaction(
21272 &mut self,
21273 ordinal: u64,
21274 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21275 ::core::future::ready(())
21276 }
21277}
21278
21279impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
21280where
21281 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
21282 ___T: ::fidl_next::Transport,
21283 <receiver::Receive as ::fidl_next::Method>::Request:
21284 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
21285{
21286 async fn on_one_way(
21287 handler: &mut ___H,
21288 ordinal: u64,
21289 flexibility: ::fidl_next::protocol::Flexibility,
21290 buffer: ___T::RecvBuffer,
21291 ) -> ::core::result::Result<
21292 (),
21293 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21294 > {
21295 match ordinal {
21296 340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
21297 Ok(decoded) => {
21298 handler.receive(decoded).await;
21299 Ok(())
21300 }
21301 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21302 ordinal: 340832707723008660,
21303 error,
21304 }),
21305 },
21306
21307 ordinal => {
21308 handler.on_unknown_interaction(ordinal).await;
21309 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21310 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21311 } else {
21312 Ok(())
21313 }
21314 }
21315 }
21316 }
21317
21318 async fn on_two_way(
21319 handler: &mut ___H,
21320 ordinal: u64,
21321 flexibility: ::fidl_next::protocol::Flexibility,
21322 buffer: ___T::RecvBuffer,
21323 responder: ::fidl_next::protocol::Responder<___T>,
21324 ) -> ::core::result::Result<
21325 (),
21326 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21327 > {
21328 match ordinal {
21329 ordinal => {
21330 handler.on_unknown_interaction(ordinal).await;
21331 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21332 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21333 } else {
21334 responder
21335 .respond(
21336 ordinal,
21337 flexibility,
21338 ::fidl_next::Flexible::<()>::FrameworkErr(
21339 ::fidl_next::FrameworkError::UnknownMethod,
21340 ),
21341 )
21342 .expect("encoding a framework error should never fail")
21343 .await?;
21344 Ok(())
21345 }
21346 }
21347 }
21348 }
21349}
21350
21351pub mod compat {
21353
21354 impl ::fidl_next::CompatFrom<crate::Availability>
21355 for ::fidl_fuchsia_component_sandbox::Availability
21356 {
21357 fn compat_from(value: crate::Availability) -> Self {
21358 match value {
21359 crate::Availability::Required => Self::Required,
21360
21361 crate::Availability::Optional => Self::Optional,
21362
21363 crate::Availability::SameAsTarget => Self::SameAsTarget,
21364
21365 crate::Availability::Transitional => Self::Transitional,
21366 }
21367 }
21368 }
21369
21370 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Availability>
21371 for crate::Availability
21372 {
21373 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Availability) -> Self {
21374 match value {
21375 ::fidl_fuchsia_component_sandbox::Availability::Required => Self::Required,
21376
21377 ::fidl_fuchsia_component_sandbox::Availability::Optional => Self::Optional,
21378
21379 ::fidl_fuchsia_component_sandbox::Availability::SameAsTarget => Self::SameAsTarget,
21380
21381 ::fidl_fuchsia_component_sandbox::Availability::Transitional => Self::Transitional,
21382 }
21383 }
21384 }
21385
21386 impl ::fidl_next::CompatFrom<crate::Unit> for ::fidl_fuchsia_component_sandbox::Unit {
21387 #[inline]
21388 fn compat_from(value: crate::Unit) -> Self {
21389 Self {}
21390 }
21391 }
21392
21393 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unit> for crate::Unit {
21394 #[inline]
21395 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unit) -> Self {
21396 Self {}
21397 }
21398 }
21399
21400 impl ::fidl_next::CompatFrom<crate::Data> for ::fidl_fuchsia_component_sandbox::Data {
21401 fn compat_from(value: crate::Data) -> Self {
21402 match value {
21403 crate::Data::Bytes(value) => {
21404 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
21405 }
21406
21407 crate::Data::String(value) => {
21408 Self::String(::fidl_next::CompatFrom::compat_from(value))
21409 }
21410
21411 crate::Data::Int64(value) => {
21412 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
21413 }
21414
21415 crate::Data::Uint64(value) => {
21416 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
21417 }
21418
21419 crate::Data::UnknownOrdinal_(unknown_ordinal) => {
21420 Self::__SourceBreaking { unknown_ordinal }
21421 }
21422 }
21423 }
21424 }
21425
21426 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Data> for crate::Data {
21427 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Data) -> Self {
21428 match value {
21429 ::fidl_fuchsia_component_sandbox::Data::Bytes(value) => {
21430 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
21431 }
21432
21433 ::fidl_fuchsia_component_sandbox::Data::String(value) => {
21434 Self::String(::fidl_next::CompatFrom::compat_from(value))
21435 }
21436
21437 ::fidl_fuchsia_component_sandbox::Data::Int64(value) => {
21438 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
21439 }
21440
21441 ::fidl_fuchsia_component_sandbox::Data::Uint64(value) => {
21442 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
21443 }
21444
21445 ::fidl_fuchsia_component_sandbox::Data::__SourceBreaking { unknown_ordinal } => {
21446 Self::UnknownOrdinal_(unknown_ordinal)
21447 }
21448 }
21449 }
21450 }
21451
21452 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
21453 for ::fidl_fuchsia_component_sandbox::DictionaryRef
21454 {
21455 #[inline]
21456 fn compat_from(value: crate::DictionaryRef) -> Self {
21457 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21458 }
21459 }
21460
21461 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
21462 for crate::DictionaryRef
21463 {
21464 #[inline]
21465 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
21466 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21467 }
21468 }
21469
21470 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
21471 #[inline]
21472 fn compat_from(value: crate::Connector) -> Self {
21473 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21474 }
21475 }
21476
21477 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
21478 #[inline]
21479 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
21480 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21481 }
21482 }
21483
21484 impl ::fidl_next::CompatFrom<crate::DirConnector>
21485 for ::fidl_fuchsia_component_sandbox::DirConnector
21486 {
21487 #[inline]
21488 fn compat_from(value: crate::DirConnector) -> Self {
21489 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21490 }
21491 }
21492
21493 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
21494 for crate::DirConnector
21495 {
21496 #[inline]
21497 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
21498 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21499 }
21500 }
21501
21502 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
21503 #[inline]
21504 fn compat_from(value: crate::DirEntry) -> Self {
21505 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21506 }
21507 }
21508
21509 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
21510 #[inline]
21511 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
21512 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21513 }
21514 }
21515
21516 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
21517 fn compat_from(value: crate::Capability) -> Self {
21518 match value {
21519 crate::Capability::Unit(value) => {
21520 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
21521 }
21522
21523 crate::Capability::Handle(value) => {
21524 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
21525 }
21526
21527 crate::Capability::Data(value) => {
21528 Self::Data(::fidl_next::CompatFrom::compat_from(value))
21529 }
21530
21531 crate::Capability::Dictionary(value) => {
21532 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
21533 }
21534
21535 crate::Capability::Connector(value) => {
21536 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
21537 }
21538
21539 crate::Capability::DirConnector(value) => {
21540 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
21541 }
21542
21543 crate::Capability::Directory(value) => {
21544 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
21545 }
21546
21547 crate::Capability::DirEntry(value) => {
21548 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
21549 }
21550
21551 crate::Capability::ConnectorRouter(value) => {
21552 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21553 }
21554
21555 crate::Capability::DictionaryRouter(value) => {
21556 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
21557 }
21558
21559 crate::Capability::DirEntryRouter(value) => {
21560 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
21561 }
21562
21563 crate::Capability::DataRouter(value) => {
21564 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
21565 }
21566
21567 crate::Capability::DirConnectorRouter(value) => {
21568 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21569 }
21570
21571 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
21572 Self::__SourceBreaking { unknown_ordinal }
21573 }
21574 }
21575 }
21576 }
21577
21578 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
21579 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
21580 match value {
21581 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
21582 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
21583 }
21584
21585 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
21586 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
21587 }
21588
21589 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
21590 Self::Data(::fidl_next::CompatFrom::compat_from(value))
21591 }
21592
21593 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
21594 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
21595 }
21596
21597 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
21598 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
21599 }
21600
21601 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
21602 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
21603 }
21604
21605 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
21606 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
21607 }
21608
21609 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
21610 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
21611 }
21612
21613 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
21614 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21615 }
21616
21617 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
21618 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
21619 }
21620
21621 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
21622 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
21623 }
21624
21625 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
21626 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
21627 }
21628
21629 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
21630 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21631 }
21632
21633 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
21634 unknown_ordinal,
21635 } => Self::UnknownOrdinal_(unknown_ordinal),
21636 }
21637 }
21638 }
21639
21640 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDuplicateRequest>
21641 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
21642 {
21643 #[inline]
21644 fn compat_from(value: crate::CapabilityStoreDuplicateRequest) -> Self {
21645 Self {
21646 id: ::fidl_next::CompatFrom::compat_from(value.id),
21647
21648 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21649 }
21650 }
21651 }
21652
21653 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest>
21654 for crate::CapabilityStoreDuplicateRequest
21655 {
21656 #[inline]
21657 fn compat_from(
21658 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest,
21659 ) -> Self {
21660 Self {
21661 id: ::fidl_next::CompatFrom::compat_from(value.id),
21662
21663 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21664 }
21665 }
21666 }
21667
21668 impl ::fidl_next::CompatFrom<crate::CapabilityStoreError>
21669 for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
21670 {
21671 fn compat_from(value: crate::CapabilityStoreError) -> Self {
21672 match value {
21673 crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,
21674
21675 crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,
21676
21677 crate::CapabilityStoreError::BadCapability => Self::BadCapability,
21678
21679 crate::CapabilityStoreError::WrongType => Self::WrongType,
21680
21681 crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,
21682
21683 crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,
21684
21685 crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,
21686
21687 crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,
21688
21689 crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,
21690
21691 crate::CapabilityStoreError::UnknownOrdinal_(unknown_ordinal) => {
21692 Self::__SourceBreaking { unknown_ordinal }
21693 }
21694 }
21695 }
21696 }
21697
21698 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreError>
21699 for crate::CapabilityStoreError
21700 {
21701 fn compat_from(value: ::fidl_fuchsia_component_sandbox::CapabilityStoreError) -> Self {
21702 match value {
21703 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdNotFound => {
21704 Self::IdNotFound
21705 }
21706
21707 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdAlreadyExists => {
21708 Self::IdAlreadyExists
21709 }
21710
21711 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::BadCapability => {
21712 Self::BadCapability
21713 }
21714
21715 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::WrongType => {
21716 Self::WrongType
21717 }
21718
21719 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::NotDuplicatable => {
21720 Self::NotDuplicatable
21721 }
21722
21723 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemNotFound => {
21724 Self::ItemNotFound
21725 }
21726
21727 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemAlreadyExists => {
21728 Self::ItemAlreadyExists
21729 }
21730
21731 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidKey => {
21732 Self::InvalidKey
21733 }
21734
21735 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidArgs => {
21736 Self::InvalidArgs
21737 }
21738
21739 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::__SourceBreaking {
21740 unknown_ordinal: value,
21741 } => Self::UnknownOrdinal_(value),
21742 }
21743 }
21744 }
21745
21746 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDropRequest>
21747 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
21748 {
21749 #[inline]
21750 fn compat_from(value: crate::CapabilityStoreDropRequest) -> Self {
21751 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21752 }
21753 }
21754
21755 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest>
21756 for crate::CapabilityStoreDropRequest
21757 {
21758 #[inline]
21759 fn compat_from(
21760 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest,
21761 ) -> Self {
21762 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21763 }
21764 }
21765
21766 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportRequest>
21767 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
21768 {
21769 #[inline]
21770 fn compat_from(value: crate::CapabilityStoreExportRequest) -> Self {
21771 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21772 }
21773 }
21774
21775 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest>
21776 for crate::CapabilityStoreExportRequest
21777 {
21778 #[inline]
21779 fn compat_from(
21780 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest,
21781 ) -> Self {
21782 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21783 }
21784 }
21785
21786 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
21787 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
21788 {
21789 #[inline]
21790 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
21791 Self {
21792 id: ::fidl_next::CompatFrom::compat_from(value.id),
21793
21794 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
21795 }
21796 }
21797 }
21798
21799 impl
21800 ::fidl_next::CompatFrom<
21801 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
21802 > for crate::CapabilityStoreConnectorCreateRequest
21803 {
21804 #[inline]
21805 fn compat_from(
21806 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
21807 ) -> Self {
21808 Self {
21809 id: ::fidl_next::CompatFrom::compat_from(value.id),
21810
21811 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
21812 }
21813 }
21814 }
21815
21816 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
21817 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
21818 {
21819 #[inline]
21820 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
21821 Self {
21822 id: ::fidl_next::CompatFrom::compat_from(value.id),
21823
21824 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21825 }
21826 }
21827 }
21828
21829 impl
21830 ::fidl_next::CompatFrom<
21831 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
21832 > for crate::CapabilityStoreConnectorOpenRequest
21833 {
21834 #[inline]
21835 fn compat_from(
21836 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
21837 ) -> Self {
21838 Self {
21839 id: ::fidl_next::CompatFrom::compat_from(value.id),
21840
21841 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21842 }
21843 }
21844 }
21845
21846 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCreateRequest>
21847 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
21848 {
21849 #[inline]
21850 fn compat_from(value: crate::CapabilityStoreDictionaryCreateRequest) -> Self {
21851 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21852 }
21853 }
21854
21855 impl
21856 ::fidl_next::CompatFrom<
21857 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
21858 > for crate::CapabilityStoreDictionaryCreateRequest
21859 {
21860 #[inline]
21861 fn compat_from(
21862 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
21863 ) -> Self {
21864 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21865 }
21866 }
21867
21868 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
21869 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
21870 {
21871 #[inline]
21872 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
21873 Self {
21874 id: ::fidl_next::CompatFrom::compat_from(value.id),
21875
21876 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
21877 }
21878 }
21879 }
21880
21881 impl
21882 ::fidl_next::CompatFrom<
21883 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
21884 > for crate::CapabilityStoreDictionaryLegacyImportRequest
21885 {
21886 #[inline]
21887 fn compat_from(
21888 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
21889 ) -> Self {
21890 Self {
21891 id: ::fidl_next::CompatFrom::compat_from(value.id),
21892
21893 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
21894 }
21895 }
21896 }
21897
21898 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
21899 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
21900 {
21901 #[inline]
21902 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
21903 Self {
21904 id: ::fidl_next::CompatFrom::compat_from(value.id),
21905
21906 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21907 }
21908 }
21909 }
21910
21911 impl
21912 ::fidl_next::CompatFrom<
21913 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
21914 > for crate::CapabilityStoreDictionaryLegacyExportRequest
21915 {
21916 #[inline]
21917 fn compat_from(
21918 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
21919 ) -> Self {
21920 Self {
21921 id: ::fidl_next::CompatFrom::compat_from(value.id),
21922
21923 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21924 }
21925 }
21926 }
21927
21928 impl ::fidl_next::CompatFrom<crate::DictionaryItem>
21929 for ::fidl_fuchsia_component_sandbox::DictionaryItem
21930 {
21931 #[inline]
21932 fn compat_from(value: crate::DictionaryItem) -> Self {
21933 Self {
21934 key: ::fidl_next::CompatFrom::compat_from(value.key),
21935
21936 value: ::fidl_next::CompatFrom::compat_from(value.value),
21937 }
21938 }
21939 }
21940
21941 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryItem>
21942 for crate::DictionaryItem
21943 {
21944 #[inline]
21945 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryItem) -> Self {
21946 Self {
21947 key: ::fidl_next::CompatFrom::compat_from(value.key),
21948
21949 value: ::fidl_next::CompatFrom::compat_from(value.value),
21950 }
21951 }
21952 }
21953
21954 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryInsertRequest>
21955 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
21956 {
21957 #[inline]
21958 fn compat_from(value: crate::CapabilityStoreDictionaryInsertRequest) -> Self {
21959 Self {
21960 id: ::fidl_next::CompatFrom::compat_from(value.id),
21961
21962 item: ::fidl_next::CompatFrom::compat_from(value.item),
21963 }
21964 }
21965 }
21966
21967 impl
21968 ::fidl_next::CompatFrom<
21969 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
21970 > for crate::CapabilityStoreDictionaryInsertRequest
21971 {
21972 #[inline]
21973 fn compat_from(
21974 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
21975 ) -> Self {
21976 Self {
21977 id: ::fidl_next::CompatFrom::compat_from(value.id),
21978
21979 item: ::fidl_next::CompatFrom::compat_from(value.item),
21980 }
21981 }
21982 }
21983
21984 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryGetRequest>
21985 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
21986 {
21987 #[inline]
21988 fn compat_from(value: crate::CapabilityStoreDictionaryGetRequest) -> Self {
21989 Self {
21990 id: ::fidl_next::CompatFrom::compat_from(value.id),
21991
21992 key: ::fidl_next::CompatFrom::compat_from(value.key),
21993
21994 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21995 }
21996 }
21997 }
21998
21999 impl
22000 ::fidl_next::CompatFrom<
22001 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
22002 > for crate::CapabilityStoreDictionaryGetRequest
22003 {
22004 #[inline]
22005 fn compat_from(
22006 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
22007 ) -> Self {
22008 Self {
22009 id: ::fidl_next::CompatFrom::compat_from(value.id),
22010
22011 key: ::fidl_next::CompatFrom::compat_from(value.key),
22012
22013 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22014 }
22015 }
22016 }
22017
22018 impl ::fidl_next::CompatFrom<crate::WrappedCapabilityId>
22019 for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
22020 {
22021 #[inline]
22022 fn compat_from(value: crate::WrappedCapabilityId) -> Self {
22023 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
22024 }
22025 }
22026
22027 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::WrappedCapabilityId>
22028 for crate::WrappedCapabilityId
22029 {
22030 #[inline]
22031 fn compat_from(value: ::fidl_fuchsia_component_sandbox::WrappedCapabilityId) -> Self {
22032 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
22033 }
22034 }
22035
22036 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryRemoveRequest>
22037 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
22038 {
22039 #[inline]
22040 fn compat_from(value: crate::CapabilityStoreDictionaryRemoveRequest) -> Self {
22041 Self {
22042 id: ::fidl_next::CompatFrom::compat_from(value.id),
22043
22044 key: ::fidl_next::CompatFrom::compat_from(value.key),
22045
22046 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22047 }
22048 }
22049 }
22050
22051 impl
22052 ::fidl_next::CompatFrom<
22053 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
22054 > for crate::CapabilityStoreDictionaryRemoveRequest
22055 {
22056 #[inline]
22057 fn compat_from(
22058 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
22059 ) -> Self {
22060 Self {
22061 id: ::fidl_next::CompatFrom::compat_from(value.id),
22062
22063 key: ::fidl_next::CompatFrom::compat_from(value.key),
22064
22065 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22066 }
22067 }
22068 }
22069
22070 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCopyRequest>
22071 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
22072 {
22073 #[inline]
22074 fn compat_from(value: crate::CapabilityStoreDictionaryCopyRequest) -> Self {
22075 Self {
22076 id: ::fidl_next::CompatFrom::compat_from(value.id),
22077
22078 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22079 }
22080 }
22081 }
22082
22083 impl
22084 ::fidl_next::CompatFrom<
22085 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
22086 > for crate::CapabilityStoreDictionaryCopyRequest
22087 {
22088 #[inline]
22089 fn compat_from(
22090 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
22091 ) -> Self {
22092 Self {
22093 id: ::fidl_next::CompatFrom::compat_from(value.id),
22094
22095 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22096 }
22097 }
22098 }
22099
22100 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
22101 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
22102 {
22103 #[inline]
22104 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
22105 Self {
22106 id: ::fidl_next::CompatFrom::compat_from(value.id),
22107
22108 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22109 }
22110 }
22111 }
22112
22113 impl
22114 ::fidl_next::CompatFrom<
22115 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
22116 > for crate::CapabilityStoreDictionaryKeysRequest
22117 {
22118 #[inline]
22119 fn compat_from(
22120 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
22121 ) -> Self {
22122 Self {
22123 id: ::fidl_next::CompatFrom::compat_from(value.id),
22124
22125 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22126 }
22127 }
22128 }
22129
22130 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
22131 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
22132 {
22133 #[inline]
22134 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
22135 Self {
22136 id: ::fidl_next::CompatFrom::compat_from(value.id),
22137
22138 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22139 }
22140 }
22141 }
22142
22143 impl
22144 ::fidl_next::CompatFrom<
22145 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
22146 > for crate::CapabilityStoreDictionaryEnumerateRequest
22147 {
22148 #[inline]
22149 fn compat_from(
22150 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
22151 ) -> Self {
22152 Self {
22153 id: ::fidl_next::CompatFrom::compat_from(value.id),
22154
22155 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22156 }
22157 }
22158 }
22159
22160 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
22161 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
22162 {
22163 #[inline]
22164 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
22165 Self {
22166 id: ::fidl_next::CompatFrom::compat_from(value.id),
22167
22168 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22169 }
22170 }
22171 }
22172
22173 impl
22174 ::fidl_next::CompatFrom<
22175 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
22176 > for crate::CapabilityStoreDictionaryDrainRequest
22177 {
22178 #[inline]
22179 fn compat_from(
22180 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
22181 ) -> Self {
22182 Self {
22183 id: ::fidl_next::CompatFrom::compat_from(value.id),
22184
22185 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22186 }
22187 }
22188 }
22189
22190 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
22191 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
22192 {
22193 #[inline]
22194 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
22195 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
22196 }
22197 }
22198
22199 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
22200 for crate::CapabilityStoreExportResponse
22201 {
22202 #[inline]
22203 fn compat_from(
22204 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
22205 ) -> Self {
22206 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
22207 }
22208 }
22209
22210 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
22211 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
22212 {
22213 #[inline]
22214 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
22215 Self {
22216 id: ::fidl_next::CompatFrom::compat_from(value.id),
22217
22218 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
22219 }
22220 }
22221 }
22222
22223 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
22224 for crate::CapabilityStoreImportRequest
22225 {
22226 #[inline]
22227 fn compat_from(
22228 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
22229 ) -> Self {
22230 Self {
22231 id: ::fidl_next::CompatFrom::compat_from(value.id),
22232
22233 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
22234 }
22235 }
22236 }
22237
22238 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
22239 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
22240 {
22241 #[inline]
22242 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
22243 Self {
22244 id: ::fidl_next::CompatFrom::compat_from(value.id),
22245
22246 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
22247 }
22248 }
22249 }
22250
22251 impl
22252 ::fidl_next::CompatFrom<
22253 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
22254 > for crate::CapabilityStoreDirConnectorCreateRequest
22255 {
22256 #[inline]
22257 fn compat_from(
22258 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
22259 ) -> Self {
22260 Self {
22261 id: ::fidl_next::CompatFrom::compat_from(value.id),
22262
22263 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
22264 }
22265 }
22266 }
22267
22268 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
22269 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
22270 {
22271 #[inline]
22272 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
22273 Self {
22274 id: ::fidl_next::CompatFrom::compat_from(value.id),
22275
22276 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
22277 }
22278 }
22279 }
22280
22281 impl
22282 ::fidl_next::CompatFrom<
22283 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
22284 > for crate::CapabilityStoreDirConnectorOpenRequest
22285 {
22286 #[inline]
22287 fn compat_from(
22288 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
22289 ) -> Self {
22290 Self {
22291 id: ::fidl_next::CompatFrom::compat_from(value.id),
22292
22293 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
22294 }
22295 }
22296 }
22297
22298 #[cfg(target_os = "fuchsia")]
22299 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
22302
22303 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
22304 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
22305 {
22306 fn compat_from(_: crate::CapabilityStore) -> Self {
22307 Self
22308 }
22309 }
22310
22311 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
22312 for crate::CapabilityStore
22313 {
22314 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
22315 Self
22316 }
22317 }
22318
22319 #[cfg(target_os = "fuchsia")]
22320
22321 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
22322 for crate::CapabilityStore
22323 {
22324 fn client_compat_from(
22325 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
22326 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22327 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22328 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22329 ::fidl_next::ClientDispatcher::new(client_end)
22330 }
22331 }
22332
22333 impl ::fidl_next::CompatFrom<crate::InstanceToken>
22334 for ::fidl_fuchsia_component_sandbox::InstanceToken
22335 {
22336 #[inline]
22337 fn compat_from(value: crate::InstanceToken) -> Self {
22338 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
22339 }
22340 }
22341
22342 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
22343 for crate::InstanceToken
22344 {
22345 #[inline]
22346 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
22347 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
22348 }
22349 }
22350
22351 impl ::fidl_next::CompatFrom<crate::RouteRequest>
22352 for ::fidl_fuchsia_component_sandbox::RouteRequest
22353 {
22354 fn compat_from(value: crate::RouteRequest) -> Self {
22355 Self {
22356 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
22357
22358 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
22359
22360 __source_breaking: ::fidl::marker::SourceBreaking,
22361 }
22362 }
22363 }
22364
22365 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
22366 for crate::RouteRequest
22367 {
22368 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
22369 Self {
22370 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
22371
22372 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
22373 }
22374 }
22375 }
22376
22377 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
22378 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
22379 {
22380 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
22381 match value {
22382 crate::ConnectorRouterRouteResponse::Connector(value) => {
22383 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
22384 }
22385
22386 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
22387 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22388 }
22389 }
22390 }
22391 }
22392
22393 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
22394 for crate::ConnectorRouterRouteResponse
22395 {
22396 fn compat_from(
22397 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
22398 ) -> Self {
22399 match value {
22400 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
22401 value,
22402 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
22403
22404 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
22405 value,
22406 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
22407 }
22408 }
22409 }
22410
22411 impl ::fidl_next::CompatFrom<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
22412 fn compat_from(value: crate::RouterError) -> Self {
22413 match value {
22414 crate::RouterError::NotFound => Self::NotFound,
22415
22416 crate::RouterError::InvalidArgs => Self::InvalidArgs,
22417
22418 crate::RouterError::NotSupported => Self::NotSupported,
22419
22420 crate::RouterError::Internal => Self::Internal,
22421
22422 crate::RouterError::UnknownOrdinal_(unknown_ordinal) => {
22423 Self::__SourceBreaking { unknown_ordinal }
22424 }
22425 }
22426 }
22427 }
22428
22429 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouterError> for crate::RouterError {
22430 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouterError) -> Self {
22431 match value {
22432 ::fidl_fuchsia_component_sandbox::RouterError::NotFound => Self::NotFound,
22433
22434 ::fidl_fuchsia_component_sandbox::RouterError::InvalidArgs => Self::InvalidArgs,
22435
22436 ::fidl_fuchsia_component_sandbox::RouterError::NotSupported => Self::NotSupported,
22437
22438 ::fidl_fuchsia_component_sandbox::RouterError::Internal => Self::Internal,
22439
22440 ::fidl_fuchsia_component_sandbox::RouterError::__SourceBreaking {
22441 unknown_ordinal: value,
22442 } => Self::UnknownOrdinal_(value),
22443 }
22444 }
22445 }
22446
22447 #[cfg(target_os = "fuchsia")]
22448 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
22451
22452 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
22453 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
22454 {
22455 fn compat_from(_: crate::ConnectorRouter) -> Self {
22456 Self
22457 }
22458 }
22459
22460 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
22461 for crate::ConnectorRouter
22462 {
22463 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
22464 Self
22465 }
22466 }
22467
22468 #[cfg(target_os = "fuchsia")]
22469
22470 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
22471 for crate::ConnectorRouter
22472 {
22473 fn client_compat_from(
22474 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
22475 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22476 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22477 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22478 ::fidl_next::ClientDispatcher::new(client_end)
22479 }
22480 }
22481
22482 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
22483 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
22484 {
22485 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
22486 match value {
22487 crate::DataRouterRouteResponse::Data(value) => {
22488 Self::Data(::fidl_next::CompatFrom::compat_from(value))
22489 }
22490
22491 crate::DataRouterRouteResponse::Unavailable(value) => {
22492 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22493 }
22494 }
22495 }
22496 }
22497
22498 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
22499 for crate::DataRouterRouteResponse
22500 {
22501 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
22502 match value {
22503 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
22504 Self::Data(::fidl_next::CompatFrom::compat_from(value))
22505 }
22506
22507 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
22508 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22509 }
22510 }
22511 }
22512 }
22513
22514 #[cfg(target_os = "fuchsia")]
22515 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
22518
22519 impl ::fidl_next::CompatFrom<crate::DataRouter>
22520 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
22521 {
22522 fn compat_from(_: crate::DataRouter) -> Self {
22523 Self
22524 }
22525 }
22526
22527 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
22528 for crate::DataRouter
22529 {
22530 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
22531 Self
22532 }
22533 }
22534
22535 #[cfg(target_os = "fuchsia")]
22536
22537 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
22538 for crate::DataRouter
22539 {
22540 fn client_compat_from(
22541 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
22542 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22543 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22544 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22545 ::fidl_next::ClientDispatcher::new(client_end)
22546 }
22547 }
22548
22549 #[cfg(target_os = "fuchsia")]
22550 pub type DictionaryProxy = ::fidl_next::Client<crate::Dictionary>;
22553
22554 impl ::fidl_next::CompatFrom<crate::Dictionary>
22555 for ::fidl_fuchsia_component_sandbox::DictionaryMarker
22556 {
22557 fn compat_from(_: crate::Dictionary) -> Self {
22558 Self
22559 }
22560 }
22561
22562 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryMarker>
22563 for crate::Dictionary
22564 {
22565 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryMarker) -> Self {
22566 Self
22567 }
22568 }
22569
22570 #[cfg(target_os = "fuchsia")]
22571
22572 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryProxy>
22573 for crate::Dictionary
22574 {
22575 fn client_compat_from(
22576 proxy: ::fidl_fuchsia_component_sandbox::DictionaryProxy,
22577 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22578 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22579 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22580 ::fidl_next::ClientDispatcher::new(client_end)
22581 }
22582 }
22583
22584 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextRequest>
22585 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
22586 {
22587 #[inline]
22588 fn compat_from(value: crate::DictionaryDrainIteratorGetNextRequest) -> Self {
22589 Self {
22590 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22591
22592 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22593 }
22594 }
22595 }
22596
22597 impl
22598 ::fidl_next::CompatFrom<
22599 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
22600 > for crate::DictionaryDrainIteratorGetNextRequest
22601 {
22602 #[inline]
22603 fn compat_from(
22604 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
22605 ) -> Self {
22606 Self {
22607 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22608
22609 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22610 }
22611 }
22612 }
22613
22614 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
22615 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
22616 {
22617 #[inline]
22618 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
22619 Self {
22620 items: ::fidl_next::CompatFrom::compat_from(value.items),
22621
22622 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22623 }
22624 }
22625 }
22626
22627 impl
22628 ::fidl_next::CompatFrom<
22629 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
22630 > for crate::DictionaryDrainIteratorGetNextResponse
22631 {
22632 #[inline]
22633 fn compat_from(
22634 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
22635 ) -> Self {
22636 Self {
22637 items: ::fidl_next::CompatFrom::compat_from(value.items),
22638
22639 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22640 }
22641 }
22642 }
22643
22644 #[cfg(target_os = "fuchsia")]
22645 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
22648
22649 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
22650 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
22651 {
22652 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
22653 Self
22654 }
22655 }
22656
22657 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
22658 for crate::DictionaryDrainIterator
22659 {
22660 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
22661 Self
22662 }
22663 }
22664
22665 #[cfg(target_os = "fuchsia")]
22666
22667 impl
22668 ::fidl_next::ClientCompatFrom<
22669 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
22670 > for crate::DictionaryDrainIterator
22671 {
22672 fn client_compat_from(
22673 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
22674 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22675 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22676 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22677 ::fidl_next::ClientDispatcher::new(client_end)
22678 }
22679 }
22680
22681 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextRequest>
22682 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
22683 {
22684 #[inline]
22685 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextRequest) -> Self {
22686 Self {
22687 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22688
22689 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22690 }
22691 }
22692 }
22693
22694 impl
22695 ::fidl_next::CompatFrom<
22696 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
22697 > for crate::DictionaryEnumerateIteratorGetNextRequest
22698 {
22699 #[inline]
22700 fn compat_from(
22701 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
22702 ) -> Self {
22703 Self {
22704 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22705
22706 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22707 }
22708 }
22709 }
22710
22711 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
22712 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
22713 {
22714 #[inline]
22715 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
22716 Self {
22717 key: ::fidl_next::CompatFrom::compat_from(value.key),
22718
22719 value: ::fidl_next::CompatFrom::compat_from(value.value),
22720 }
22721 }
22722 }
22723
22724 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
22725 for crate::DictionaryOptionalItem
22726 {
22727 #[inline]
22728 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
22729 Self {
22730 key: ::fidl_next::CompatFrom::compat_from(value.key),
22731
22732 value: ::fidl_next::CompatFrom::compat_from(value.value),
22733 }
22734 }
22735 }
22736
22737 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
22738 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
22739 {
22740 #[inline]
22741 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
22742 Self {
22743 items: ::fidl_next::CompatFrom::compat_from(value.items),
22744
22745 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22746 }
22747 }
22748 }
22749
22750 impl
22751 ::fidl_next::CompatFrom<
22752 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
22753 > for crate::DictionaryEnumerateIteratorGetNextResponse
22754 {
22755 #[inline]
22756 fn compat_from(
22757 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
22758 ) -> Self {
22759 Self {
22760 items: ::fidl_next::CompatFrom::compat_from(value.items),
22761
22762 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22763 }
22764 }
22765 }
22766
22767 #[cfg(target_os = "fuchsia")]
22768 pub type DictionaryEnumerateIteratorProxy =
22771 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
22772
22773 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
22774 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
22775 {
22776 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
22777 Self
22778 }
22779 }
22780
22781 impl
22782 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
22783 for crate::DictionaryEnumerateIterator
22784 {
22785 fn compat_from(
22786 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
22787 ) -> Self {
22788 Self
22789 }
22790 }
22791
22792 #[cfg(target_os = "fuchsia")]
22793
22794 impl
22795 ::fidl_next::ClientCompatFrom<
22796 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
22797 > for crate::DictionaryEnumerateIterator
22798 {
22799 fn client_compat_from(
22800 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
22801 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22802 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22803 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22804 ::fidl_next::ClientDispatcher::new(client_end)
22805 }
22806 }
22807
22808 impl ::fidl_next::CompatFrom<crate::DictionaryError>
22809 for ::fidl_fuchsia_component_sandbox::DictionaryError
22810 {
22811 fn compat_from(value: crate::DictionaryError) -> Self {
22812 match value {
22813 crate::DictionaryError::NotFound => Self::NotFound,
22814
22815 crate::DictionaryError::AlreadyExists => Self::AlreadyExists,
22816
22817 crate::DictionaryError::BadCapability => Self::BadCapability,
22818
22819 crate::DictionaryError::InvalidKey => Self::InvalidKey,
22820
22821 crate::DictionaryError::NotCloneable => Self::NotCloneable,
22822
22823 crate::DictionaryError::UnknownOrdinal_(unknown_ordinal) => {
22824 Self::__SourceBreaking { unknown_ordinal }
22825 }
22826 }
22827 }
22828 }
22829
22830 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryError>
22831 for crate::DictionaryError
22832 {
22833 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryError) -> Self {
22834 match value {
22835 ::fidl_fuchsia_component_sandbox::DictionaryError::NotFound => Self::NotFound,
22836
22837 ::fidl_fuchsia_component_sandbox::DictionaryError::AlreadyExists => {
22838 Self::AlreadyExists
22839 }
22840
22841 ::fidl_fuchsia_component_sandbox::DictionaryError::BadCapability => {
22842 Self::BadCapability
22843 }
22844
22845 ::fidl_fuchsia_component_sandbox::DictionaryError::InvalidKey => Self::InvalidKey,
22846
22847 ::fidl_fuchsia_component_sandbox::DictionaryError::NotCloneable => {
22848 Self::NotCloneable
22849 }
22850
22851 ::fidl_fuchsia_component_sandbox::DictionaryError::__SourceBreaking {
22852 unknown_ordinal: value,
22853 } => Self::UnknownOrdinal_(value),
22854 }
22855 }
22856 }
22857
22858 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
22859 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
22860 {
22861 #[inline]
22862 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
22863 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
22864 }
22865 }
22866
22867 impl
22868 ::fidl_next::CompatFrom<
22869 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
22870 > for crate::DictionaryKeysIteratorGetNextResponse
22871 {
22872 #[inline]
22873 fn compat_from(
22874 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
22875 ) -> Self {
22876 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
22877 }
22878 }
22879
22880 #[cfg(target_os = "fuchsia")]
22881 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
22884
22885 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
22886 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
22887 {
22888 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
22889 Self
22890 }
22891 }
22892
22893 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
22894 for crate::DictionaryKeysIterator
22895 {
22896 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
22897 Self
22898 }
22899 }
22900
22901 #[cfg(target_os = "fuchsia")]
22902
22903 impl
22904 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
22905 for crate::DictionaryKeysIterator
22906 {
22907 fn client_compat_from(
22908 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
22909 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22910 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22911 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22912 ::fidl_next::ClientDispatcher::new(client_end)
22913 }
22914 }
22915
22916 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
22917 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
22918 {
22919 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
22920 match value {
22921 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
22922 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
22923 }
22924
22925 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
22926 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22927 }
22928 }
22929 }
22930 }
22931
22932 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
22933 for crate::DictionaryRouterRouteResponse
22934 {
22935 fn compat_from(
22936 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
22937 ) -> Self {
22938 match value {
22939 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
22940 value,
22941 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
22942
22943 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
22944 value,
22945 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
22946 }
22947 }
22948 }
22949
22950 #[cfg(target_os = "fuchsia")]
22951 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
22954
22955 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
22956 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
22957 {
22958 fn compat_from(_: crate::DictionaryRouter) -> Self {
22959 Self
22960 }
22961 }
22962
22963 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
22964 for crate::DictionaryRouter
22965 {
22966 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
22967 Self
22968 }
22969 }
22970
22971 #[cfg(target_os = "fuchsia")]
22972
22973 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
22974 for crate::DictionaryRouter
22975 {
22976 fn client_compat_from(
22977 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
22978 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22979 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22980 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22981 ::fidl_next::ClientDispatcher::new(client_end)
22982 }
22983 }
22984
22985 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
22986 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
22987 {
22988 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
22989 match value {
22990 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
22991 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
22992 }
22993
22994 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
22995 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22996 }
22997 }
22998 }
22999 }
23000
23001 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
23002 for crate::DirConnectorRouterRouteResponse
23003 {
23004 fn compat_from(
23005 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
23006 ) -> Self {
23007 match value {
23008 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
23009 value,
23010 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
23011
23012 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
23013 value,
23014 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23015 }
23016 }
23017 }
23018
23019 #[cfg(target_os = "fuchsia")]
23020 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
23023
23024 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
23025 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
23026 {
23027 fn compat_from(_: crate::DirConnectorRouter) -> Self {
23028 Self
23029 }
23030 }
23031
23032 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
23033 for crate::DirConnectorRouter
23034 {
23035 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
23036 Self
23037 }
23038 }
23039
23040 #[cfg(target_os = "fuchsia")]
23041
23042 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
23043 for crate::DirConnectorRouter
23044 {
23045 fn client_compat_from(
23046 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
23047 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23048 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23049 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23050 ::fidl_next::ClientDispatcher::new(client_end)
23051 }
23052 }
23053
23054 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
23055 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
23056 {
23057 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
23058 match value {
23059 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
23060 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
23061 }
23062
23063 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
23064 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
23065 }
23066 }
23067 }
23068 }
23069
23070 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
23071 for crate::DirEntryRouterRouteResponse
23072 {
23073 fn compat_from(
23074 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
23075 ) -> Self {
23076 match value {
23077 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
23078 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
23079 }
23080
23081 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
23082 value,
23083 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23084 }
23085 }
23086 }
23087
23088 #[cfg(target_os = "fuchsia")]
23089 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
23092
23093 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
23094 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
23095 {
23096 fn compat_from(_: crate::DirEntryRouter) -> Self {
23097 Self
23098 }
23099 }
23100
23101 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
23102 for crate::DirEntryRouter
23103 {
23104 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
23105 Self
23106 }
23107 }
23108
23109 #[cfg(target_os = "fuchsia")]
23110
23111 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
23112 for crate::DirEntryRouter
23113 {
23114 fn client_compat_from(
23115 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
23116 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23117 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23118 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23119 ::fidl_next::ClientDispatcher::new(client_end)
23120 }
23121 }
23122
23123 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
23124 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
23125 {
23126 #[inline]
23127 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
23128 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23129 }
23130 }
23131
23132 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
23133 for crate::DirReceiverReceiveRequest
23134 {
23135 #[inline]
23136 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
23137 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23138 }
23139 }
23140
23141 #[cfg(target_os = "fuchsia")]
23142 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
23145
23146 impl ::fidl_next::CompatFrom<crate::DirReceiver>
23147 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
23148 {
23149 fn compat_from(_: crate::DirReceiver) -> Self {
23150 Self
23151 }
23152 }
23153
23154 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
23155 for crate::DirReceiver
23156 {
23157 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
23158 Self
23159 }
23160 }
23161
23162 #[cfg(target_os = "fuchsia")]
23163
23164 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
23165 for crate::DirReceiver
23166 {
23167 fn client_compat_from(
23168 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
23169 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23170 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23171 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23172 ::fidl_next::ClientDispatcher::new(client_end)
23173 }
23174 }
23175
23176 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
23177 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
23178 {
23179 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
23180 match value {
23181 crate::DirectoryRouterRouteResponse::Directory(value) => {
23182 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
23183 }
23184
23185 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
23186 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
23187 }
23188 }
23189 }
23190 }
23191
23192 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
23193 for crate::DirectoryRouterRouteResponse
23194 {
23195 fn compat_from(
23196 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
23197 ) -> Self {
23198 match value {
23199 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
23200 value,
23201 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
23202
23203 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
23204 value,
23205 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23206 }
23207 }
23208 }
23209
23210 #[cfg(target_os = "fuchsia")]
23211 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
23214
23215 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
23216 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
23217 {
23218 fn compat_from(_: crate::DirectoryRouter) -> Self {
23219 Self
23220 }
23221 }
23222
23223 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
23224 for crate::DirectoryRouter
23225 {
23226 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
23227 Self
23228 }
23229 }
23230
23231 #[cfg(target_os = "fuchsia")]
23232
23233 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
23234 for crate::DirectoryRouter
23235 {
23236 fn client_compat_from(
23237 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
23238 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23239 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23240 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23241 ::fidl_next::ClientDispatcher::new(client_end)
23242 }
23243 }
23244
23245 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
23246 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
23247 {
23248 #[inline]
23249 fn compat_from(value: crate::ProtocolPayload) -> Self {
23250 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23251 }
23252 }
23253
23254 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
23255 for crate::ProtocolPayload
23256 {
23257 #[inline]
23258 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
23259 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23260 }
23261 }
23262
23263 #[cfg(target_os = "fuchsia")]
23264 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
23267
23268 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
23269 fn compat_from(_: crate::Receiver) -> Self {
23270 Self
23271 }
23272 }
23273
23274 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
23275 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
23276 Self
23277 }
23278 }
23279
23280 #[cfg(target_os = "fuchsia")]
23281
23282 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
23283 for crate::Receiver
23284 {
23285 fn client_compat_from(
23286 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
23287 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23288 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23289 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23290 ::fidl_next::ClientDispatcher::new(client_end)
23291 }
23292 }
23293
23294 impl ::fidl_next::CompatFrom<crate::Unavailable> for ::fidl_fuchsia_component_sandbox::Unavailable {
23295 #[inline]
23296 fn compat_from(value: crate::Unavailable) -> Self {
23297 Self {}
23298 }
23299 }
23300
23301 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unavailable> for crate::Unavailable {
23302 #[inline]
23303 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unavailable) -> Self {
23304 Self {}
23305 }
23306 }
23307}