1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5#[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"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u32)]
8pub enum Availability {
9 Required = 1,
10 Optional = 2,
11 SameAsTarget = 3,
12 Transitional = 4,
13}
14
15impl ::fidl_next::Encodable for Availability {
16 type Encoded = WireAvailability;
17}
18impl ::core::convert::TryFrom<u32> for Availability {
19 type Error = ::fidl_next::UnknownStrictEnumMemberError;
20 fn try_from(
21 value: u32,
22 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
23 match value {
24 1 => Ok(Self::Required),
25 2 => Ok(Self::Optional),
26 3 => Ok(Self::SameAsTarget),
27 4 => Ok(Self::Transitional),
28
29 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
30 }
31 }
32}
33
34unsafe impl<___E> ::fidl_next::Encode<___E> for Availability
35where
36 ___E: ?Sized,
37{
38 #[inline]
39 fn encode(
40 self,
41 encoder: &mut ___E,
42 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
45 }
46}
47
48unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Availability
49where
50 ___E: ?Sized,
51{
52 #[inline]
53 fn encode_ref(
54 &self,
55 encoder: &mut ___E,
56 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
57 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
58 ::fidl_next::munge!(let WireAvailability { value } = out);
59 let _ = value.write(::fidl_next::WireU32::from(match *self {
60 Self::Required => 1,
61
62 Self::Optional => 2,
63
64 Self::SameAsTarget => 3,
65
66 Self::Transitional => 4,
67 }));
68
69 Ok(())
70 }
71}
72
73impl ::core::convert::From<WireAvailability> for Availability {
74 fn from(wire: WireAvailability) -> Self {
75 match u32::from(wire.value) {
76 1 => Self::Required,
77
78 2 => Self::Optional,
79
80 3 => Self::SameAsTarget,
81
82 4 => Self::Transitional,
83
84 _ => unsafe { ::core::hint::unreachable_unchecked() },
85 }
86 }
87}
88
89impl ::fidl_next::FromWire<WireAvailability> for Availability {
90 #[inline]
91 fn from_wire(wire: WireAvailability) -> Self {
92 Self::from(wire)
93 }
94}
95
96impl ::fidl_next::IntoNatural for WireAvailability {
97 type Natural = Availability;
98}
99
100impl ::fidl_next::FromWireRef<WireAvailability> for Availability {
101 #[inline]
102 fn from_wire_ref(wire: &WireAvailability) -> Self {
103 Self::from(*wire)
104 }
105}
106
107#[derive(Clone, Copy, Debug, PartialEq, Eq)]
109#[repr(transparent)]
110pub struct WireAvailability {
111 value: ::fidl_next::WireU32,
112}
113
114unsafe impl ::fidl_next::Wire for WireAvailability {
115 type Decoded<'de> = Self;
116
117 #[inline]
118 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
119 }
121}
122
123impl WireAvailability {
124 pub const REQUIRED: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(1) };
125
126 pub const OPTIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(2) };
127
128 pub const SAME_AS_TARGET: WireAvailability =
129 WireAvailability { value: ::fidl_next::WireU32(3) };
130
131 pub const TRANSITIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(4) };
132}
133
134unsafe impl<___D> ::fidl_next::Decode<___D> for WireAvailability
135where
136 ___D: ?Sized,
137{
138 fn decode(
139 slot: ::fidl_next::Slot<'_, Self>,
140 _: &mut ___D,
141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
142 ::fidl_next::munge!(let Self { value } = slot);
143
144 match u32::from(*value) {
145 1 | 2 | 3 | 4 => (),
146 unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
147 }
148
149 Ok(())
150 }
151}
152
153impl ::core::convert::From<Availability> for WireAvailability {
154 fn from(natural: Availability) -> Self {
155 match natural {
156 Availability::Required => WireAvailability::REQUIRED,
157
158 Availability::Optional => WireAvailability::OPTIONAL,
159
160 Availability::SameAsTarget => WireAvailability::SAME_AS_TARGET,
161
162 Availability::Transitional => WireAvailability::TRANSITIONAL,
163 }
164 }
165}
166
167#[derive(PartialEq, Clone, Debug)]
168#[repr(C)]
169pub struct Unit {}
170
171impl ::fidl_next::Encodable for Unit {
172 type Encoded = WireUnit;
173}
174
175unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
176where
177 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
178{
179 #[inline]
180 fn encode(
181 self,
182 encoder_: &mut ___E,
183 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185 *out_ = ::core::mem::MaybeUninit::zeroed();
186
187 Ok(())
188 }
189}
190
191unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unit
192where
193 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
194{
195 #[inline]
196 fn encode_ref(
197 &self,
198 encoder_: &mut ___E,
199 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
201 ::fidl_next::munge! {
202 let Self::Encoded {
203
204 _empty,
205
206
207 } = out_;
208 }
209
210 Ok(())
211 }
212}
213
214impl ::fidl_next::EncodableOption for Unit {
215 type EncodedOption = ::fidl_next::WireBox<'static, WireUnit>;
216}
217
218unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unit
219where
220 ___E: ::fidl_next::Encoder + ?Sized,
221 Unit: ::fidl_next::Encode<___E>,
222{
223 #[inline]
224 fn encode_option(
225 this: ::core::option::Option<Self>,
226 encoder: &mut ___E,
227 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
228 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
229 if let Some(inner) = this {
230 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
231 ::fidl_next::WireBox::encode_present(out);
232 } else {
233 ::fidl_next::WireBox::encode_absent(out);
234 }
235
236 Ok(())
237 }
238}
239
240unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unit
241where
242 ___E: ::fidl_next::Encoder + ?Sized,
243 Unit: ::fidl_next::EncodeRef<___E>,
244{
245 #[inline]
246 fn encode_option_ref(
247 this: ::core::option::Option<&Self>,
248 encoder: &mut ___E,
249 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
250 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
251 if let Some(inner) = this {
252 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
253 ::fidl_next::WireBox::encode_present(out);
254 } else {
255 ::fidl_next::WireBox::encode_absent(out);
256 }
257
258 Ok(())
259 }
260}
261
262impl ::fidl_next::FromWire<WireUnit> for Unit {
263 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireUnit, Self> =
264 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
265
266 #[inline]
267 fn from_wire(wire: WireUnit) -> Self {
268 Self {}
269 }
270}
271
272impl ::fidl_next::IntoNatural for WireUnit {
273 type Natural = Unit;
274}
275
276impl ::fidl_next::FromWireRef<WireUnit> for Unit {
277 #[inline]
278 fn from_wire_ref(wire: &WireUnit) -> Self {
279 Self {}
280 }
281}
282
283#[derive(Clone, Debug)]
285#[repr(C)]
286pub struct WireUnit {
287 _empty: fidl_next::WireEmptyStructPlaceholder,
288}
289static_assertions::const_assert_eq!(std::mem::size_of::<WireUnit>(), 1);
290static_assertions::const_assert_eq!(std::mem::align_of::<WireUnit>(), 1);
291
292unsafe impl ::fidl_next::Wire for WireUnit {
293 type Decoded<'de> = WireUnit;
294
295 #[inline]
296 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
297 ::fidl_next::munge! {
298 let Self {
299
300 _empty,
301
302
303 } = &mut *out_;
304 }
305 }
306}
307
308unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnit
309where
310 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
311{
312 fn decode(
313 slot_: ::fidl_next::Slot<'_, Self>,
314 decoder_: &mut ___D,
315 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
316 ::fidl_next::munge! {
317 let Self {
318
319 mut _empty,
320
321
322 } = slot_;
323 }
324
325 if _empty.as_bytes() != &[0u8] {
326 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
327 }
328
329 Ok(())
330 }
331}
332
333#[doc = " Maximum number of bytes in a [Data].\n"]
334pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
335
336#[derive(PartialEq, Clone, Debug)]
337pub enum Data {
338 Bytes(::std::vec::Vec<u8>),
339
340 String(::std::string::String),
341
342 Int64(i64),
343
344 Uint64(u64),
345
346 UnknownOrdinal_(u64),
347}
348
349impl ::fidl_next::Encodable for Data {
350 type Encoded = WireData<'static>;
351}
352
353unsafe impl<___E> ::fidl_next::Encode<___E> for Data
354where
355 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
356 ___E: ::fidl_next::Encoder,
357{
358 #[inline]
359 fn encode(
360 self,
361 encoder: &mut ___E,
362 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
363 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
364 ::fidl_next::munge!(let WireData { raw, _phantom: _ } = out);
365
366 match self {
367 Self::Bytes(value) => {
368 ::fidl_next::RawWireUnion::encode_as::<___E, ::std::vec::Vec<u8>>(
369 value, 1, encoder, raw,
370 )?
371 }
372
373 Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
374 ___E,
375 ::std::string::String,
376 >(value, 2, encoder, raw)?,
377
378 Self::Int64(value) => {
379 ::fidl_next::RawWireUnion::encode_as::<___E, i64>(value, 3, encoder, raw)?
380 }
381
382 Self::Uint64(value) => {
383 ::fidl_next::RawWireUnion::encode_as::<___E, u64>(value, 4, encoder, raw)?
384 }
385
386 Self::UnknownOrdinal_(ordinal) => {
387 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
388 }
389 }
390
391 Ok(())
392 }
393}
394
395unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Data
396where
397 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
398 ___E: ::fidl_next::Encoder,
399{
400 #[inline]
401 fn encode_ref(
402 &self,
403 encoder: &mut ___E,
404 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
405 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
406 ::fidl_next::munge!(let WireData { raw, _phantom: _ } = out);
407
408 match self {
409 Self::Bytes(value) => {
410 ::fidl_next::RawWireUnion::encode_as::<___E, &::std::vec::Vec<u8>>(
411 value, 1, encoder, raw,
412 )?
413 }
414
415 Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
416 ___E,
417 &::std::string::String,
418 >(value, 2, encoder, raw)?,
419
420 Self::Int64(value) => {
421 ::fidl_next::RawWireUnion::encode_as::<___E, &i64>(value, 3, encoder, raw)?
422 }
423
424 Self::Uint64(value) => {
425 ::fidl_next::RawWireUnion::encode_as::<___E, &u64>(value, 4, encoder, raw)?
426 }
427
428 Self::UnknownOrdinal_(ordinal) => {
429 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
430 }
431 }
432
433 Ok(())
434 }
435}
436
437impl ::fidl_next::EncodableOption for Data {
438 type EncodedOption = WireOptionalData<'static>;
439}
440
441unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Data
442where
443 ___E: ?Sized,
444 Data: ::fidl_next::Encode<___E>,
445{
446 #[inline]
447 fn encode_option(
448 this: ::core::option::Option<Self>,
449 encoder: &mut ___E,
450 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
451 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
452 ::fidl_next::munge!(let WireOptionalData { raw, _phantom: _ } = &mut *out);
453
454 if let Some(inner) = this {
455 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
456 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
457 } else {
458 ::fidl_next::RawWireUnion::encode_absent(raw);
459 }
460
461 Ok(())
462 }
463}
464
465unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Data
466where
467 ___E: ?Sized,
468 Data: ::fidl_next::EncodeRef<___E>,
469{
470 #[inline]
471 fn encode_option_ref(
472 this: ::core::option::Option<&Self>,
473 encoder: &mut ___E,
474 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
475 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
476 ::fidl_next::munge!(let WireOptionalData { raw, _phantom: _ } = &mut *out);
477
478 if let Some(inner) = this {
479 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
480 ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out)?;
481 } else {
482 ::fidl_next::RawWireUnion::encode_absent(raw);
483 }
484
485 Ok(())
486 }
487}
488
489impl<'de> ::fidl_next::FromWire<WireData<'de>> for Data {
490 #[inline]
491 fn from_wire(wire: WireData<'de>) -> Self {
492 let wire = ::core::mem::ManuallyDrop::new(wire);
493 match wire.raw.ordinal() {
494 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
495 wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
496 })),
497
498 2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
499 wire.raw.get().read_unchecked::<::fidl_next::WireString<'de>>()
500 })),
501
502 3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
503 wire.raw.get().read_unchecked::<::fidl_next::WireI64>()
504 })),
505
506 4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
507 wire.raw.get().read_unchecked::<::fidl_next::WireU64>()
508 })),
509
510 _ => unsafe { ::core::hint::unreachable_unchecked() },
511 }
512 }
513}
514
515impl<'de> ::fidl_next::IntoNatural for WireData<'de> {
516 type Natural = Data;
517}
518
519impl<'de> ::fidl_next::FromWireRef<WireData<'de>> for Data {
520 #[inline]
521 fn from_wire_ref(wire: &WireData<'de>) -> Self {
522 match wire.raw.ordinal() {
523 1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
524 wire.raw.get().deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
525 })),
526
527 2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
528 wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
529 })),
530
531 3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
532 wire.raw.get().deref_unchecked::<::fidl_next::WireI64>()
533 })),
534
535 4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
536 wire.raw.get().deref_unchecked::<::fidl_next::WireU64>()
537 })),
538
539 _ => unsafe { ::core::hint::unreachable_unchecked() },
540 }
541 }
542}
543
544impl<'de> ::fidl_next::FromWireOption<WireOptionalData<'de>> for Data {
545 #[inline]
546 fn from_wire_option(wire: WireOptionalData<'de>) -> ::core::option::Option<Self> {
547 if let Some(inner) = wire.into_option() {
548 Some(::fidl_next::FromWire::from_wire(inner))
549 } else {
550 None
551 }
552 }
553}
554
555impl<'de> ::fidl_next::IntoNatural for WireOptionalData<'de> {
556 type Natural = ::core::option::Option<Data>;
557}
558
559impl<'de> ::fidl_next::FromWireOption<WireOptionalData<'de>> for Box<Data> {
560 #[inline]
561 fn from_wire_option(wire: WireOptionalData<'de>) -> ::core::option::Option<Self> {
562 <Data as ::fidl_next::FromWireOption<WireOptionalData<'de>>>::from_wire_option(wire)
563 .map(Box::new)
564 }
565}
566
567impl<'de> ::fidl_next::FromWireOptionRef<WireOptionalData<'de>> for Box<Data> {
568 #[inline]
569 fn from_wire_option_ref(wire: &WireOptionalData<'de>) -> ::core::option::Option<Self> {
570 if let Some(inner) = wire.as_ref() {
571 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
572 } else {
573 None
574 }
575 }
576}
577
578#[repr(transparent)]
580pub struct WireData<'de> {
581 raw: ::fidl_next::RawWireUnion,
582 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
583}
584
585impl<'de> Drop for WireData<'de> {
586 fn drop(&mut self) {
587 match self.raw.ordinal() {
588 1 => {
589 let _ =
590 unsafe { self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>() };
591 }
592
593 2 => {
594 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireString<'de>>() };
595 }
596
597 3 => {
598 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI64>() };
599 }
600
601 4 => {
602 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU64>() };
603 }
604
605 _ => (),
606 }
607 }
608}
609
610unsafe impl ::fidl_next::Wire for WireData<'static> {
611 type Decoded<'de> = WireData<'de>;
612
613 #[inline]
614 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
615 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
616 ::fidl_next::RawWireUnion::zero_padding(raw);
617 }
618}
619
620pub mod data {
621 pub enum Ref<'de> {
622 Bytes(&'de ::fidl_next::WireVector<'de, u8>),
623
624 String(&'de ::fidl_next::WireString<'de>),
625
626 Int64(&'de ::fidl_next::WireI64),
627
628 Uint64(&'de ::fidl_next::WireU64),
629
630 UnknownOrdinal_(u64),
631 }
632}
633
634impl<'de> WireData<'de> {
635 pub fn as_ref(&self) -> crate::data::Ref<'_> {
636 match self.raw.ordinal() {
637 1 => crate::data::Ref::Bytes(unsafe {
638 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
639 }),
640
641 2 => crate::data::Ref::String(unsafe {
642 self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
643 }),
644
645 3 => crate::data::Ref::Int64(unsafe {
646 self.raw.get().deref_unchecked::<::fidl_next::WireI64>()
647 }),
648
649 4 => crate::data::Ref::Uint64(unsafe {
650 self.raw.get().deref_unchecked::<::fidl_next::WireU64>()
651 }),
652
653 unknown => crate::data::Ref::UnknownOrdinal_(unknown),
654 }
655 }
656}
657
658unsafe impl<___D> ::fidl_next::Decode<___D> for WireData<'static>
659where
660 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
661 ___D: ::fidl_next::Decoder,
662{
663 fn decode(
664 mut slot: ::fidl_next::Slot<'_, Self>,
665 decoder: &mut ___D,
666 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
667 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
668 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
669 1 => {
670 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
671 raw, decoder,
672 )?
673 }
674
675 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
676 raw, decoder,
677 )?,
678
679 3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,
680
681 4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,
682
683 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
684 }
685
686 Ok(())
687 }
688}
689
690impl<'de> ::core::fmt::Debug for WireData<'de> {
691 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
692 match self.raw.ordinal() {
693 1 => unsafe {
694 self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
695 },
696 2 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
697 3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
698 4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
699 _ => unsafe { ::core::hint::unreachable_unchecked() },
700 }
701 }
702}
703
704#[repr(transparent)]
705pub struct WireOptionalData<'de> {
706 raw: ::fidl_next::RawWireUnion,
707 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
708}
709
710unsafe impl ::fidl_next::Wire for WireOptionalData<'static> {
711 type Decoded<'de> = WireOptionalData<'de>;
712
713 #[inline]
714 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
715 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
716 ::fidl_next::RawWireUnion::zero_padding(raw);
717 }
718}
719
720impl<'de> WireOptionalData<'de> {
721 pub fn is_some(&self) -> bool {
722 self.raw.is_some()
723 }
724
725 pub fn is_none(&self) -> bool {
726 self.raw.is_none()
727 }
728
729 pub fn as_ref(&self) -> ::core::option::Option<&WireData<'de>> {
730 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
731 }
732
733 pub fn into_option(self) -> ::core::option::Option<WireData<'de>> {
734 if self.is_some() {
735 Some(WireData { raw: self.raw, _phantom: ::core::marker::PhantomData })
736 } else {
737 None
738 }
739 }
740}
741
742unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalData<'static>
743where
744 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
745 ___D: ::fidl_next::Decoder,
746{
747 fn decode(
748 mut slot: ::fidl_next::Slot<'_, Self>,
749 decoder: &mut ___D,
750 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
751 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
752 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
753 1 => {
754 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
755 raw, decoder,
756 )?
757 }
758
759 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
760 raw, decoder,
761 )?,
762
763 3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,
764
765 4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,
766
767 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
768 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
769 }
770
771 Ok(())
772 }
773}
774
775impl<'de> ::core::fmt::Debug for WireOptionalData<'de> {
776 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
777 self.as_ref().fmt(f)
778 }
779}
780
781#[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
782pub type Token = ::fidl_next::fuchsia::zx::EventPair;
783
784pub type WireToken = ::fidl_next::fuchsia::WireEventPair;
786
787#[derive(PartialEq, Debug)]
788#[repr(C)]
789pub struct DictionaryRef {
790 pub token: ::fidl_next::fuchsia::zx::EventPair,
791}
792
793impl ::fidl_next::Encodable for DictionaryRef {
794 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDictionaryRef> = unsafe {
795 ::fidl_next::CopyOptimization::enable_if(
796 true
797
798 && <
799 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
800 >::COPY_OPTIMIZATION.is_enabled()
801
802 )
803 };
804
805 type Encoded = WireDictionaryRef;
806}
807
808unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRef
809where
810 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
811 ___E: ::fidl_next::fuchsia::HandleEncoder,
812{
813 #[inline]
814 fn encode(
815 self,
816 encoder_: &mut ___E,
817 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
818 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
819 ::fidl_next::munge! {
820 let Self::Encoded {
821 token,
822
823 } = out_;
824 }
825
826 ::fidl_next::Encode::encode(self.token, encoder_, token)?;
827
828 Ok(())
829 }
830}
831
832impl ::fidl_next::EncodableOption for DictionaryRef {
833 type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryRef>;
834}
835
836unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRef
837where
838 ___E: ::fidl_next::Encoder + ?Sized,
839 DictionaryRef: ::fidl_next::Encode<___E>,
840{
841 #[inline]
842 fn encode_option(
843 this: ::core::option::Option<Self>,
844 encoder: &mut ___E,
845 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
847 if let Some(inner) = this {
848 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
849 ::fidl_next::WireBox::encode_present(out);
850 } else {
851 ::fidl_next::WireBox::encode_absent(out);
852 }
853
854 Ok(())
855 }
856}
857
858impl ::fidl_next::FromWire<WireDictionaryRef> for DictionaryRef {
859 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDictionaryRef, Self> = unsafe {
860 ::fidl_next::CopyOptimization::enable_if(
861 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
862 ::fidl_next::fuchsia::WireEventPair,
863 >>::COPY_OPTIMIZATION
864 .is_enabled(),
865 )
866 };
867
868 #[inline]
869 fn from_wire(wire: WireDictionaryRef) -> Self {
870 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
871 }
872}
873
874impl ::fidl_next::IntoNatural for WireDictionaryRef {
875 type Natural = DictionaryRef;
876}
877
878#[derive(Debug)]
880#[repr(C)]
881pub struct WireDictionaryRef {
882 pub token: ::fidl_next::fuchsia::WireEventPair,
883}
884static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryRef>(), 4);
885static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryRef>(), 4);
886
887static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryRef, token), 0);
888
889unsafe impl ::fidl_next::Wire for WireDictionaryRef {
890 type Decoded<'de> = WireDictionaryRef;
891
892 #[inline]
893 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
894 ::fidl_next::munge! {
895 let Self {
896
897 token,
898
899 } = &mut *out_;
900 }
901
902 ::fidl_next::Wire::zero_padding(token);
903 }
904}
905
906unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryRef
907where
908 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
909 ___D: ::fidl_next::fuchsia::HandleDecoder,
910{
911 fn decode(
912 slot_: ::fidl_next::Slot<'_, Self>,
913 decoder_: &mut ___D,
914 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
915 ::fidl_next::munge! {
916 let Self {
917
918 mut token,
919
920 } = slot_;
921 }
922
923 ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
924
925 Ok(())
926 }
927}
928
929#[derive(PartialEq, Debug)]
930#[repr(C)]
931pub struct Connector {
932 pub token: ::fidl_next::fuchsia::zx::EventPair,
933}
934
935impl ::fidl_next::Encodable for Connector {
936 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireConnector> = unsafe {
937 ::fidl_next::CopyOptimization::enable_if(
938 true
939
940 && <
941 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
942 >::COPY_OPTIMIZATION.is_enabled()
943
944 )
945 };
946
947 type Encoded = WireConnector;
948}
949
950unsafe impl<___E> ::fidl_next::Encode<___E> for Connector
951where
952 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
953 ___E: ::fidl_next::fuchsia::HandleEncoder,
954{
955 #[inline]
956 fn encode(
957 self,
958 encoder_: &mut ___E,
959 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
960 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
961 ::fidl_next::munge! {
962 let Self::Encoded {
963 token,
964
965 } = out_;
966 }
967
968 ::fidl_next::Encode::encode(self.token, encoder_, token)?;
969
970 Ok(())
971 }
972}
973
974impl ::fidl_next::EncodableOption for Connector {
975 type EncodedOption = ::fidl_next::WireBox<'static, WireConnector>;
976}
977
978unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Connector
979where
980 ___E: ::fidl_next::Encoder + ?Sized,
981 Connector: ::fidl_next::Encode<___E>,
982{
983 #[inline]
984 fn encode_option(
985 this: ::core::option::Option<Self>,
986 encoder: &mut ___E,
987 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
988 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
989 if let Some(inner) = this {
990 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
991 ::fidl_next::WireBox::encode_present(out);
992 } else {
993 ::fidl_next::WireBox::encode_absent(out);
994 }
995
996 Ok(())
997 }
998}
999
1000impl ::fidl_next::FromWire<WireConnector> for Connector {
1001 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireConnector, Self> = unsafe {
1002 ::fidl_next::CopyOptimization::enable_if(
1003 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1004 ::fidl_next::fuchsia::WireEventPair,
1005 >>::COPY_OPTIMIZATION
1006 .is_enabled(),
1007 )
1008 };
1009
1010 #[inline]
1011 fn from_wire(wire: WireConnector) -> Self {
1012 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1013 }
1014}
1015
1016impl ::fidl_next::IntoNatural for WireConnector {
1017 type Natural = Connector;
1018}
1019
1020#[derive(Debug)]
1022#[repr(C)]
1023pub struct WireConnector {
1024 pub token: ::fidl_next::fuchsia::WireEventPair,
1025}
1026static_assertions::const_assert_eq!(std::mem::size_of::<WireConnector>(), 4);
1027static_assertions::const_assert_eq!(std::mem::align_of::<WireConnector>(), 4);
1028
1029static_assertions::const_assert_eq!(std::mem::offset_of!(WireConnector, token), 0);
1030
1031unsafe impl ::fidl_next::Wire for WireConnector {
1032 type Decoded<'de> = WireConnector;
1033
1034 #[inline]
1035 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1036 ::fidl_next::munge! {
1037 let Self {
1038
1039 token,
1040
1041 } = &mut *out_;
1042 }
1043
1044 ::fidl_next::Wire::zero_padding(token);
1045 }
1046}
1047
1048unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnector
1049where
1050 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1051 ___D: ::fidl_next::fuchsia::HandleDecoder,
1052{
1053 fn decode(
1054 slot_: ::fidl_next::Slot<'_, Self>,
1055 decoder_: &mut ___D,
1056 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1057 ::fidl_next::munge! {
1058 let Self {
1059
1060 mut token,
1061
1062 } = slot_;
1063 }
1064
1065 ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1066
1067 Ok(())
1068 }
1069}
1070
1071#[derive(PartialEq, Debug)]
1072#[repr(C)]
1073pub struct DirConnector {
1074 pub token: ::fidl_next::fuchsia::zx::EventPair,
1075}
1076
1077impl ::fidl_next::Encodable for DirConnector {
1078 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirConnector> = unsafe {
1079 ::fidl_next::CopyOptimization::enable_if(
1080 true
1081
1082 && <
1083 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
1084 >::COPY_OPTIMIZATION.is_enabled()
1085
1086 )
1087 };
1088
1089 type Encoded = WireDirConnector;
1090}
1091
1092unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnector
1093where
1094 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1095 ___E: ::fidl_next::fuchsia::HandleEncoder,
1096{
1097 #[inline]
1098 fn encode(
1099 self,
1100 encoder_: &mut ___E,
1101 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1102 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1103 ::fidl_next::munge! {
1104 let Self::Encoded {
1105 token,
1106
1107 } = out_;
1108 }
1109
1110 ::fidl_next::Encode::encode(self.token, encoder_, token)?;
1111
1112 Ok(())
1113 }
1114}
1115
1116impl ::fidl_next::EncodableOption for DirConnector {
1117 type EncodedOption = ::fidl_next::WireBox<'static, WireDirConnector>;
1118}
1119
1120unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnector
1121where
1122 ___E: ::fidl_next::Encoder + ?Sized,
1123 DirConnector: ::fidl_next::Encode<___E>,
1124{
1125 #[inline]
1126 fn encode_option(
1127 this: ::core::option::Option<Self>,
1128 encoder: &mut ___E,
1129 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1130 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1131 if let Some(inner) = this {
1132 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1133 ::fidl_next::WireBox::encode_present(out);
1134 } else {
1135 ::fidl_next::WireBox::encode_absent(out);
1136 }
1137
1138 Ok(())
1139 }
1140}
1141
1142impl ::fidl_next::FromWire<WireDirConnector> for DirConnector {
1143 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirConnector, Self> = unsafe {
1144 ::fidl_next::CopyOptimization::enable_if(
1145 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1146 ::fidl_next::fuchsia::WireEventPair,
1147 >>::COPY_OPTIMIZATION
1148 .is_enabled(),
1149 )
1150 };
1151
1152 #[inline]
1153 fn from_wire(wire: WireDirConnector) -> Self {
1154 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1155 }
1156}
1157
1158impl ::fidl_next::IntoNatural for WireDirConnector {
1159 type Natural = DirConnector;
1160}
1161
1162#[derive(Debug)]
1164#[repr(C)]
1165pub struct WireDirConnector {
1166 pub token: ::fidl_next::fuchsia::WireEventPair,
1167}
1168static_assertions::const_assert_eq!(std::mem::size_of::<WireDirConnector>(), 4);
1169static_assertions::const_assert_eq!(std::mem::align_of::<WireDirConnector>(), 4);
1170
1171static_assertions::const_assert_eq!(std::mem::offset_of!(WireDirConnector, token), 0);
1172
1173unsafe impl ::fidl_next::Wire for WireDirConnector {
1174 type Decoded<'de> = WireDirConnector;
1175
1176 #[inline]
1177 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1178 ::fidl_next::munge! {
1179 let Self {
1180
1181 token,
1182
1183 } = &mut *out_;
1184 }
1185
1186 ::fidl_next::Wire::zero_padding(token);
1187 }
1188}
1189
1190unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirConnector
1191where
1192 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1193 ___D: ::fidl_next::fuchsia::HandleDecoder,
1194{
1195 fn decode(
1196 slot_: ::fidl_next::Slot<'_, Self>,
1197 decoder_: &mut ___D,
1198 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1199 ::fidl_next::munge! {
1200 let Self {
1201
1202 mut token,
1203
1204 } = slot_;
1205 }
1206
1207 ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1208
1209 Ok(())
1210 }
1211}
1212
1213#[derive(PartialEq, Debug)]
1214#[repr(C)]
1215pub struct DirEntry {
1216 pub token: ::fidl_next::fuchsia::zx::EventPair,
1217}
1218
1219impl ::fidl_next::Encodable for DirEntry {
1220 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirEntry> = unsafe {
1221 ::fidl_next::CopyOptimization::enable_if(
1222 true
1223
1224 && <
1225 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
1226 >::COPY_OPTIMIZATION.is_enabled()
1227
1228 )
1229 };
1230
1231 type Encoded = WireDirEntry;
1232}
1233
1234unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntry
1235where
1236 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1237 ___E: ::fidl_next::fuchsia::HandleEncoder,
1238{
1239 #[inline]
1240 fn encode(
1241 self,
1242 encoder_: &mut ___E,
1243 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1244 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1245 ::fidl_next::munge! {
1246 let Self::Encoded {
1247 token,
1248
1249 } = out_;
1250 }
1251
1252 ::fidl_next::Encode::encode(self.token, encoder_, token)?;
1253
1254 Ok(())
1255 }
1256}
1257
1258impl ::fidl_next::EncodableOption for DirEntry {
1259 type EncodedOption = ::fidl_next::WireBox<'static, WireDirEntry>;
1260}
1261
1262unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntry
1263where
1264 ___E: ::fidl_next::Encoder + ?Sized,
1265 DirEntry: ::fidl_next::Encode<___E>,
1266{
1267 #[inline]
1268 fn encode_option(
1269 this: ::core::option::Option<Self>,
1270 encoder: &mut ___E,
1271 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1272 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1273 if let Some(inner) = this {
1274 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1275 ::fidl_next::WireBox::encode_present(out);
1276 } else {
1277 ::fidl_next::WireBox::encode_absent(out);
1278 }
1279
1280 Ok(())
1281 }
1282}
1283
1284impl ::fidl_next::FromWire<WireDirEntry> for DirEntry {
1285 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirEntry, Self> = unsafe {
1286 ::fidl_next::CopyOptimization::enable_if(
1287 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1288 ::fidl_next::fuchsia::WireEventPair,
1289 >>::COPY_OPTIMIZATION
1290 .is_enabled(),
1291 )
1292 };
1293
1294 #[inline]
1295 fn from_wire(wire: WireDirEntry) -> Self {
1296 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1297 }
1298}
1299
1300impl ::fidl_next::IntoNatural for WireDirEntry {
1301 type Natural = DirEntry;
1302}
1303
1304#[derive(Debug)]
1306#[repr(C)]
1307pub struct WireDirEntry {
1308 pub token: ::fidl_next::fuchsia::WireEventPair,
1309}
1310static_assertions::const_assert_eq!(std::mem::size_of::<WireDirEntry>(), 4);
1311static_assertions::const_assert_eq!(std::mem::align_of::<WireDirEntry>(), 4);
1312
1313static_assertions::const_assert_eq!(std::mem::offset_of!(WireDirEntry, token), 0);
1314
1315unsafe impl ::fidl_next::Wire for WireDirEntry {
1316 type Decoded<'de> = WireDirEntry;
1317
1318 #[inline]
1319 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1320 ::fidl_next::munge! {
1321 let Self {
1322
1323 token,
1324
1325 } = &mut *out_;
1326 }
1327
1328 ::fidl_next::Wire::zero_padding(token);
1329 }
1330}
1331
1332unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirEntry
1333where
1334 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1335 ___D: ::fidl_next::fuchsia::HandleDecoder,
1336{
1337 fn decode(
1338 slot_: ::fidl_next::Slot<'_, Self>,
1339 decoder_: &mut ___D,
1340 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1341 ::fidl_next::munge! {
1342 let Self {
1343
1344 mut token,
1345
1346 } = slot_;
1347 }
1348
1349 ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1350
1351 Ok(())
1352 }
1353}
1354
1355#[derive(PartialEq, Debug)]
1356pub enum Capability {
1357 Unit(crate::Unit),
1358
1359 Handle(::fidl_next::fuchsia::zx::Handle),
1360
1361 Data(crate::Data),
1362
1363 Dictionary(crate::DictionaryRef),
1364
1365 Connector(crate::Connector),
1366
1367 DirConnector(crate::DirConnector),
1368
1369 Directory(
1370 ::fidl_next::ClientEnd<
1371 ::fidl_next_fuchsia_io::Directory,
1372 ::fidl_next::fuchsia::zx::Channel,
1373 >,
1374 ),
1375
1376 DirEntry(crate::DirEntry),
1377
1378 ConnectorRouter(
1379 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1380 ),
1381
1382 DictionaryRouter(
1383 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
1384 ),
1385
1386 DirEntryRouter(
1387 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
1388 ),
1389
1390 DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
1391
1392 DirConnectorRouter(
1393 ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1394 ),
1395
1396 UnknownOrdinal_(u64),
1397}
1398
1399impl ::fidl_next::Encodable for Capability {
1400 type Encoded = WireCapability<'static>;
1401}
1402
1403unsafe impl<___E> ::fidl_next::Encode<___E> for Capability
1404where
1405 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1406 ___E: ::fidl_next::Encoder,
1407 ___E: ::fidl_next::fuchsia::HandleEncoder,
1408{
1409 #[inline]
1410 fn encode(
1411 self,
1412 encoder: &mut ___E,
1413 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1414 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1415 ::fidl_next::munge!(let WireCapability { raw, _phantom: _ } = out);
1416
1417 match self {
1418 Self::Unit(value) => {
1419 ::fidl_next::RawWireUnion::encode_as::<___E, crate::Unit>(value, 1, encoder, raw)?
1420 }
1421
1422 Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
1423 ___E,
1424 ::fidl_next::fuchsia::zx::Handle,
1425 >(value, 2, encoder, raw)?,
1426
1427 Self::Data(value) => {
1428 ::fidl_next::RawWireUnion::encode_as::<___E, crate::Data>(value, 3, encoder, raw)?
1429 }
1430
1431 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
1432 ___E,
1433 crate::DictionaryRef,
1434 >(value, 4, encoder, raw)?,
1435
1436 Self::Connector(value) => {
1437 ::fidl_next::RawWireUnion::encode_as::<___E, crate::Connector>(
1438 value, 5, encoder, raw,
1439 )?
1440 }
1441
1442 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
1443 ___E,
1444 crate::DirConnector,
1445 >(value, 6, encoder, raw)?,
1446
1447 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
1448 ___E,
1449 ::fidl_next::ClientEnd<
1450 ::fidl_next_fuchsia_io::Directory,
1451 ::fidl_next::fuchsia::zx::Channel,
1452 >,
1453 >(value, 7, encoder, raw)?,
1454
1455 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::DirEntry>(
1456 value, 8, encoder, raw,
1457 )?,
1458
1459 Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1460 ___E,
1461 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1462 >(value, 9, encoder, raw)?,
1463
1464 Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1465 ___E,
1466 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
1467 >(value, 10, encoder, raw)?,
1468
1469 Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1470 ___E,
1471 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
1472 >(value, 11, encoder, raw)?,
1473
1474 Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1475 ___E,
1476 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>,
1477 >(value, 12, encoder, raw)?,
1478
1479 Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1480 ___E,
1481 ::fidl_next::ClientEnd<
1482 crate::DirConnectorRouter,
1483 ::fidl_next::fuchsia::zx::Channel,
1484 >,
1485 >(value, 13, encoder, raw)?,
1486
1487 Self::UnknownOrdinal_(ordinal) => {
1488 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1489 }
1490 }
1491
1492 Ok(())
1493 }
1494}
1495
1496impl ::fidl_next::EncodableOption for Capability {
1497 type EncodedOption = WireOptionalCapability<'static>;
1498}
1499
1500unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Capability
1501where
1502 ___E: ?Sized,
1503 Capability: ::fidl_next::Encode<___E>,
1504{
1505 #[inline]
1506 fn encode_option(
1507 this: ::core::option::Option<Self>,
1508 encoder: &mut ___E,
1509 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1511 ::fidl_next::munge!(let WireOptionalCapability { raw, _phantom: _ } = &mut *out);
1512
1513 if let Some(inner) = this {
1514 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1515 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
1516 } else {
1517 ::fidl_next::RawWireUnion::encode_absent(raw);
1518 }
1519
1520 Ok(())
1521 }
1522}
1523
1524impl<'de> ::fidl_next::FromWire<WireCapability<'de>> for Capability {
1525 #[inline]
1526 fn from_wire(wire: WireCapability<'de>) -> Self {
1527 let wire = ::core::mem::ManuallyDrop::new(wire);
1528 match wire.raw.ordinal() {
1529 1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
1530 wire.raw.get().read_unchecked::<crate::WireUnit>()
1531 })),
1532
1533 2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
1534 wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
1535 })),
1536
1537 3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
1538 wire.raw.get().read_unchecked::<crate::WireData<'de>>()
1539 })),
1540
1541 4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
1542 wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
1543 })),
1544
1545 5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1546 wire.raw.get().read_unchecked::<crate::WireConnector>()
1547 })),
1548
1549 6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
1550 wire.raw.get().read_unchecked::<crate::WireDirConnector>()
1551 })),
1552
1553 7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1554 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1555 ::fidl_next_fuchsia_io::Directory,
1556 ::fidl_next::fuchsia::WireChannel,
1557 >>()
1558 })),
1559
1560 8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
1561 wire.raw.get().read_unchecked::<crate::WireDirEntry>()
1562 })),
1563
1564 9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1565 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1566 crate::ConnectorRouter,
1567 ::fidl_next::fuchsia::WireChannel,
1568 >>()
1569 })),
1570
1571 10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
1572 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1573 crate::DictionaryRouter,
1574 ::fidl_next::fuchsia::WireChannel,
1575 >>()
1576 })),
1577
1578 11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
1579 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>>()
1580 })),
1581
1582 12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
1583 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1584 })),
1585
1586 13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1587 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1588 crate::DirConnectorRouter,
1589 ::fidl_next::fuchsia::WireChannel,
1590 >>()
1591 })),
1592
1593 _ => unsafe { ::core::hint::unreachable_unchecked() },
1594 }
1595 }
1596}
1597
1598impl<'de> ::fidl_next::IntoNatural for WireCapability<'de> {
1599 type Natural = Capability;
1600}
1601
1602impl<'de> ::fidl_next::FromWireOption<WireOptionalCapability<'de>> for Capability {
1603 #[inline]
1604 fn from_wire_option(wire: WireOptionalCapability<'de>) -> ::core::option::Option<Self> {
1605 if let Some(inner) = wire.into_option() {
1606 Some(::fidl_next::FromWire::from_wire(inner))
1607 } else {
1608 None
1609 }
1610 }
1611}
1612
1613impl<'de> ::fidl_next::IntoNatural for WireOptionalCapability<'de> {
1614 type Natural = ::core::option::Option<Capability>;
1615}
1616
1617impl<'de> ::fidl_next::FromWireOption<WireOptionalCapability<'de>> for Box<Capability> {
1618 #[inline]
1619 fn from_wire_option(wire: WireOptionalCapability<'de>) -> ::core::option::Option<Self> {
1620 <Capability as ::fidl_next::FromWireOption<WireOptionalCapability<'de>>>::from_wire_option(
1621 wire,
1622 )
1623 .map(Box::new)
1624 }
1625}
1626
1627#[repr(transparent)]
1629pub struct WireCapability<'de> {
1630 raw: ::fidl_next::RawWireUnion,
1631 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
1632}
1633
1634impl<'de> Drop for WireCapability<'de> {
1635 fn drop(&mut self) {
1636 match self.raw.ordinal() {
1637 1 => {
1638 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
1639 }
1640
1641 2 => {
1642 let _ =
1643 unsafe { self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>() };
1644 }
1645
1646 3 => {
1647 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireData<'de>>() };
1648 }
1649
1650 4 => {
1651 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDictionaryRef>() };
1652 }
1653
1654 5 => {
1655 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireConnector>() };
1656 }
1657
1658 6 => {
1659 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirConnector>() };
1660 }
1661
1662 7 => {
1663 let _ = unsafe {
1664 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1665 ::fidl_next_fuchsia_io::Directory,
1666 ::fidl_next::fuchsia::WireChannel,
1667 >>()
1668 };
1669 }
1670
1671 8 => {
1672 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirEntry>() };
1673 }
1674
1675 9 => {
1676 let _ = unsafe {
1677 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1678 crate::ConnectorRouter,
1679 ::fidl_next::fuchsia::WireChannel,
1680 >>()
1681 };
1682 }
1683
1684 10 => {
1685 let _ = unsafe {
1686 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1687 crate::DictionaryRouter,
1688 ::fidl_next::fuchsia::WireChannel,
1689 >>()
1690 };
1691 }
1692
1693 11 => {
1694 let _ = unsafe {
1695 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1696 crate::DirEntryRouter,
1697 ::fidl_next::fuchsia::WireChannel,
1698 >>()
1699 };
1700 }
1701
1702 12 => {
1703 let _ = unsafe {
1704 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1705 };
1706 }
1707
1708 13 => {
1709 let _ = unsafe {
1710 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1711 crate::DirConnectorRouter,
1712 ::fidl_next::fuchsia::WireChannel,
1713 >>()
1714 };
1715 }
1716
1717 _ => (),
1718 }
1719 }
1720}
1721
1722unsafe impl ::fidl_next::Wire for WireCapability<'static> {
1723 type Decoded<'de> = WireCapability<'de>;
1724
1725 #[inline]
1726 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
1727 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
1728 ::fidl_next::RawWireUnion::zero_padding(raw);
1729 }
1730}
1731
1732pub mod capability {
1733 pub enum Ref<'de> {
1734 Unit(&'de crate::WireUnit),
1735
1736 Handle(&'de ::fidl_next::fuchsia::WireHandle),
1737
1738 Data(&'de crate::WireData<'de>),
1739
1740 Dictionary(&'de crate::WireDictionaryRef),
1741
1742 Connector(&'de crate::WireConnector),
1743
1744 DirConnector(&'de crate::WireDirConnector),
1745
1746 Directory(
1747 &'de ::fidl_next::ClientEnd<
1748 ::fidl_next_fuchsia_io::Directory,
1749 ::fidl_next::fuchsia::WireChannel,
1750 >,
1751 ),
1752
1753 DirEntry(&'de crate::WireDirEntry),
1754
1755 ConnectorRouter(
1756 &'de ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
1757 ),
1758
1759 DictionaryRouter(
1760 &'de ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
1761 ),
1762
1763 DirEntryRouter(
1764 &'de ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
1765 ),
1766
1767 DataRouter(
1768 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
1769 ),
1770
1771 DirConnectorRouter(
1772 &'de ::fidl_next::ClientEnd<
1773 crate::DirConnectorRouter,
1774 ::fidl_next::fuchsia::WireChannel,
1775 >,
1776 ),
1777
1778 UnknownOrdinal_(u64),
1779 }
1780}
1781
1782impl<'de> WireCapability<'de> {
1783 pub fn as_ref(&self) -> crate::capability::Ref<'_> {
1784 match self.raw.ordinal() {
1785 1 => crate::capability::Ref::Unit(unsafe {
1786 self.raw.get().deref_unchecked::<crate::WireUnit>()
1787 }),
1788
1789 2 => crate::capability::Ref::Handle(unsafe {
1790 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
1791 }),
1792
1793 3 => crate::capability::Ref::Data(unsafe {
1794 self.raw.get().deref_unchecked::<crate::WireData<'_>>()
1795 }),
1796
1797 4 => crate::capability::Ref::Dictionary(unsafe {
1798 self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
1799 }),
1800
1801 5 => crate::capability::Ref::Connector(unsafe {
1802 self.raw.get().deref_unchecked::<crate::WireConnector>()
1803 }),
1804
1805 6 => crate::capability::Ref::DirConnector(unsafe {
1806 self.raw.get().deref_unchecked::<crate::WireDirConnector>()
1807 }),
1808
1809 7 => crate::capability::Ref::Directory(unsafe {
1810 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1811 ::fidl_next_fuchsia_io::Directory,
1812 ::fidl_next::fuchsia::WireChannel,
1813 >>()
1814 }),
1815
1816 8 => crate::capability::Ref::DirEntry(unsafe {
1817 self.raw.get().deref_unchecked::<crate::WireDirEntry>()
1818 }),
1819
1820 9 => crate::capability::Ref::ConnectorRouter(unsafe {
1821 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1822 crate::ConnectorRouter,
1823 ::fidl_next::fuchsia::WireChannel,
1824 >>()
1825 }),
1826
1827 10 => crate::capability::Ref::DictionaryRouter(unsafe {
1828 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1829 crate::DictionaryRouter,
1830 ::fidl_next::fuchsia::WireChannel,
1831 >>()
1832 }),
1833
1834 11 => crate::capability::Ref::DirEntryRouter(unsafe {
1835 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>>()
1836 }),
1837
1838 12 => crate::capability::Ref::DataRouter(unsafe {
1839 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1840 }),
1841
1842 13 => crate::capability::Ref::DirConnectorRouter(unsafe {
1843 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1844 crate::DirConnectorRouter,
1845 ::fidl_next::fuchsia::WireChannel,
1846 >>()
1847 }),
1848
1849 unknown => crate::capability::Ref::UnknownOrdinal_(unknown),
1850 }
1851 }
1852}
1853
1854unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapability<'static>
1855where
1856 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1857 ___D: ::fidl_next::Decoder,
1858 ___D: ::fidl_next::fuchsia::HandleDecoder,
1859{
1860 fn decode(
1861 mut slot: ::fidl_next::Slot<'_, Self>,
1862 decoder: &mut ___D,
1863 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1864 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
1865 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
1866 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
1867
1868 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
1869 raw, decoder,
1870 )?,
1871
1872 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
1873 raw, decoder,
1874 )?,
1875
1876 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDictionaryRef>(
1877 raw, decoder,
1878 )?,
1879
1880 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,
1881
1882 6 => {
1883 ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirConnector>(raw, decoder)?
1884 }
1885
1886 7 => ::fidl_next::RawWireUnion::decode_as::<
1887 ___D,
1888 ::fidl_next::ClientEnd<
1889 ::fidl_next_fuchsia_io::Directory,
1890 ::fidl_next::fuchsia::WireChannel,
1891 >,
1892 >(raw, decoder)?,
1893
1894 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,
1895
1896 9 => ::fidl_next::RawWireUnion::decode_as::<
1897 ___D,
1898 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
1899 >(raw, decoder)?,
1900
1901 10 => ::fidl_next::RawWireUnion::decode_as::<
1902 ___D,
1903 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
1904 >(raw, decoder)?,
1905
1906 11 => ::fidl_next::RawWireUnion::decode_as::<
1907 ___D,
1908 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
1909 >(raw, decoder)?,
1910
1911 12 => ::fidl_next::RawWireUnion::decode_as::<
1912 ___D,
1913 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
1914 >(raw, decoder)?,
1915
1916 13 => ::fidl_next::RawWireUnion::decode_as::<
1917 ___D,
1918 ::fidl_next::ClientEnd<
1919 crate::DirConnectorRouter,
1920 ::fidl_next::fuchsia::WireChannel,
1921 >,
1922 >(raw, decoder)?,
1923
1924 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
1925 }
1926
1927 Ok(())
1928 }
1929}
1930
1931impl<'de> ::core::fmt::Debug for WireCapability<'de> {
1932 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1933 match self.raw.ordinal() {
1934 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
1935 2 => unsafe {
1936 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
1937 },
1938 3 => unsafe { self.raw.get().deref_unchecked::<crate::WireData<'_>>().fmt(f) },
1939 4 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionaryRef>().fmt(f) },
1940 5 => unsafe { self.raw.get().deref_unchecked::<crate::WireConnector>().fmt(f) },
1941 6 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirConnector>().fmt(f) },
1942 7 => unsafe {
1943 self.raw
1944 .get()
1945 .deref_unchecked::<::fidl_next::ClientEnd<
1946 ::fidl_next_fuchsia_io::Directory,
1947 ::fidl_next::fuchsia::WireChannel,
1948 >>()
1949 .fmt(f)
1950 },
1951 8 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
1952 9 => unsafe {
1953 self.raw
1954 .get()
1955 .deref_unchecked::<::fidl_next::ClientEnd<
1956 crate::ConnectorRouter,
1957 ::fidl_next::fuchsia::WireChannel,
1958 >>()
1959 .fmt(f)
1960 },
1961 10 => unsafe {
1962 self.raw
1963 .get()
1964 .deref_unchecked::<::fidl_next::ClientEnd<
1965 crate::DictionaryRouter,
1966 ::fidl_next::fuchsia::WireChannel,
1967 >>()
1968 .fmt(f)
1969 },
1970 11 => unsafe {
1971 self.raw.get().deref_unchecked::<
1972 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>
1973 >().fmt(f)
1974 },
1975 12 => unsafe {
1976 self.raw.get().deref_unchecked::<
1977 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
1978 >().fmt(f)
1979 },
1980 13 => unsafe {
1981 self.raw
1982 .get()
1983 .deref_unchecked::<::fidl_next::ClientEnd<
1984 crate::DirConnectorRouter,
1985 ::fidl_next::fuchsia::WireChannel,
1986 >>()
1987 .fmt(f)
1988 },
1989 _ => unsafe { ::core::hint::unreachable_unchecked() },
1990 }
1991 }
1992}
1993
1994#[repr(transparent)]
1995pub struct WireOptionalCapability<'de> {
1996 raw: ::fidl_next::RawWireUnion,
1997 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
1998}
1999
2000unsafe impl ::fidl_next::Wire for WireOptionalCapability<'static> {
2001 type Decoded<'de> = WireOptionalCapability<'de>;
2002
2003 #[inline]
2004 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2005 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2006 ::fidl_next::RawWireUnion::zero_padding(raw);
2007 }
2008}
2009
2010impl<'de> WireOptionalCapability<'de> {
2011 pub fn is_some(&self) -> bool {
2012 self.raw.is_some()
2013 }
2014
2015 pub fn is_none(&self) -> bool {
2016 self.raw.is_none()
2017 }
2018
2019 pub fn as_ref(&self) -> ::core::option::Option<&WireCapability<'de>> {
2020 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
2021 }
2022
2023 pub fn into_option(self) -> ::core::option::Option<WireCapability<'de>> {
2024 if self.is_some() {
2025 Some(WireCapability { raw: self.raw, _phantom: ::core::marker::PhantomData })
2026 } else {
2027 None
2028 }
2029 }
2030}
2031
2032unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalCapability<'static>
2033where
2034 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2035 ___D: ::fidl_next::Decoder,
2036 ___D: ::fidl_next::fuchsia::HandleDecoder,
2037{
2038 fn decode(
2039 mut slot: ::fidl_next::Slot<'_, Self>,
2040 decoder: &mut ___D,
2041 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2042 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2043 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
2044 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
2045
2046 2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
2047 raw, decoder,
2048 )?,
2049
2050 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
2051 raw, decoder,
2052 )?,
2053
2054 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDictionaryRef>(
2055 raw, decoder,
2056 )?,
2057
2058 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,
2059
2060 6 => {
2061 ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirConnector>(raw, decoder)?
2062 }
2063
2064 7 => ::fidl_next::RawWireUnion::decode_as::<
2065 ___D,
2066 ::fidl_next::ClientEnd<
2067 ::fidl_next_fuchsia_io::Directory,
2068 ::fidl_next::fuchsia::WireChannel,
2069 >,
2070 >(raw, decoder)?,
2071
2072 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,
2073
2074 9 => ::fidl_next::RawWireUnion::decode_as::<
2075 ___D,
2076 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
2077 >(raw, decoder)?,
2078
2079 10 => ::fidl_next::RawWireUnion::decode_as::<
2080 ___D,
2081 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
2082 >(raw, decoder)?,
2083
2084 11 => ::fidl_next::RawWireUnion::decode_as::<
2085 ___D,
2086 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
2087 >(raw, decoder)?,
2088
2089 12 => ::fidl_next::RawWireUnion::decode_as::<
2090 ___D,
2091 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
2092 >(raw, decoder)?,
2093
2094 13 => ::fidl_next::RawWireUnion::decode_as::<
2095 ___D,
2096 ::fidl_next::ClientEnd<
2097 crate::DirConnectorRouter,
2098 ::fidl_next::fuchsia::WireChannel,
2099 >,
2100 >(raw, decoder)?,
2101
2102 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
2103 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
2104 }
2105
2106 Ok(())
2107 }
2108}
2109
2110impl<'de> ::core::fmt::Debug for WireOptionalCapability<'de> {
2111 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2112 self.as_ref().fmt(f)
2113 }
2114}
2115
2116#[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"]
2117pub type CapabilityId = u64;
2118
2119pub type WireCapabilityId = ::fidl_next::WireU64;
2121
2122#[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"]
2123pub type NewCapabilityId = u64;
2124
2125pub type WireNewCapabilityId = ::fidl_next::WireU64;
2127
2128#[derive(PartialEq, Clone, Debug)]
2129#[repr(C)]
2130pub struct CapabilityStoreDuplicateRequest {
2131 pub id: u64,
2132
2133 pub dest_id: u64,
2134}
2135
2136impl ::fidl_next::Encodable for CapabilityStoreDuplicateRequest {
2137 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2138 Self,
2139 WireCapabilityStoreDuplicateRequest,
2140 > = unsafe {
2141 ::fidl_next::CopyOptimization::enable_if(
2142 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
2143 && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2144 )
2145 };
2146
2147 type Encoded = WireCapabilityStoreDuplicateRequest;
2148}
2149
2150unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest
2151where
2152 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2153{
2154 #[inline]
2155 fn encode(
2156 self,
2157 encoder_: &mut ___E,
2158 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2160 ::fidl_next::munge! {
2161 let Self::Encoded {
2162 id,
2163 dest_id,
2164
2165 } = out_;
2166 }
2167
2168 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2169
2170 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
2171
2172 Ok(())
2173 }
2174}
2175
2176unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateRequest
2177where
2178 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2179{
2180 #[inline]
2181 fn encode_ref(
2182 &self,
2183 encoder_: &mut ___E,
2184 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2185 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2186 ::fidl_next::munge! {
2187 let Self::Encoded {
2188
2189 id,
2190 dest_id,
2191
2192 } = out_;
2193 }
2194
2195 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2196
2197 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
2198
2199 Ok(())
2200 }
2201}
2202
2203impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateRequest {
2204 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDuplicateRequest>;
2205}
2206
2207unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateRequest
2208where
2209 ___E: ::fidl_next::Encoder + ?Sized,
2210 CapabilityStoreDuplicateRequest: ::fidl_next::Encode<___E>,
2211{
2212 #[inline]
2213 fn encode_option(
2214 this: ::core::option::Option<Self>,
2215 encoder: &mut ___E,
2216 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2217 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2218 if let Some(inner) = this {
2219 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2220 ::fidl_next::WireBox::encode_present(out);
2221 } else {
2222 ::fidl_next::WireBox::encode_absent(out);
2223 }
2224
2225 Ok(())
2226 }
2227}
2228
2229unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateRequest
2230where
2231 ___E: ::fidl_next::Encoder + ?Sized,
2232 CapabilityStoreDuplicateRequest: ::fidl_next::EncodeRef<___E>,
2233{
2234 #[inline]
2235 fn encode_option_ref(
2236 this: ::core::option::Option<&Self>,
2237 encoder: &mut ___E,
2238 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2240 if let Some(inner) = this {
2241 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2242 ::fidl_next::WireBox::encode_present(out);
2243 } else {
2244 ::fidl_next::WireBox::encode_absent(out);
2245 }
2246
2247 Ok(())
2248 }
2249}
2250
2251impl ::fidl_next::FromWire<WireCapabilityStoreDuplicateRequest>
2252 for CapabilityStoreDuplicateRequest
2253{
2254 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2255 WireCapabilityStoreDuplicateRequest,
2256 Self,
2257 > = unsafe {
2258 ::fidl_next::CopyOptimization::enable_if(
2259 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2260 .is_enabled()
2261 && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2262 .is_enabled(),
2263 )
2264 };
2265
2266 #[inline]
2267 fn from_wire(wire: WireCapabilityStoreDuplicateRequest) -> Self {
2268 Self {
2269 id: ::fidl_next::FromWire::from_wire(wire.id),
2270
2271 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
2272 }
2273 }
2274}
2275
2276impl ::fidl_next::IntoNatural for WireCapabilityStoreDuplicateRequest {
2277 type Natural = CapabilityStoreDuplicateRequest;
2278}
2279
2280impl ::fidl_next::FromWireRef<WireCapabilityStoreDuplicateRequest>
2281 for CapabilityStoreDuplicateRequest
2282{
2283 #[inline]
2284 fn from_wire_ref(wire: &WireCapabilityStoreDuplicateRequest) -> Self {
2285 Self {
2286 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
2287
2288 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
2289 }
2290 }
2291}
2292
2293#[derive(Clone, Debug)]
2295#[repr(C)]
2296pub struct WireCapabilityStoreDuplicateRequest {
2297 pub id: ::fidl_next::WireU64,
2298
2299 pub dest_id: ::fidl_next::WireU64,
2300}
2301static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreDuplicateRequest>(), 16);
2302static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreDuplicateRequest>(), 8);
2303
2304static_assertions::const_assert_eq!(
2305 std::mem::offset_of!(WireCapabilityStoreDuplicateRequest, id),
2306 0
2307);
2308
2309static_assertions::const_assert_eq!(
2310 std::mem::offset_of!(WireCapabilityStoreDuplicateRequest, dest_id),
2311 8
2312);
2313
2314unsafe impl ::fidl_next::Wire for WireCapabilityStoreDuplicateRequest {
2315 type Decoded<'de> = WireCapabilityStoreDuplicateRequest;
2316
2317 #[inline]
2318 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2319 ::fidl_next::munge! {
2320 let Self {
2321
2322 id,
2323 dest_id,
2324
2325 } = &mut *out_;
2326 }
2327
2328 ::fidl_next::Wire::zero_padding(id);
2329
2330 ::fidl_next::Wire::zero_padding(dest_id);
2331 }
2332}
2333
2334unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDuplicateRequest
2335where
2336 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2337{
2338 fn decode(
2339 slot_: ::fidl_next::Slot<'_, Self>,
2340 decoder_: &mut ___D,
2341 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2342 ::fidl_next::munge! {
2343 let Self {
2344
2345 mut id,
2346 mut dest_id,
2347
2348 } = slot_;
2349 }
2350
2351 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2352
2353 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
2354
2355 Ok(())
2356 }
2357}
2358
2359pub type CapabilityStoreDuplicateResponse = ();
2360
2361pub type WireCapabilityStoreDuplicateResponse = ();
2363
2364#[doc = " Error returned from methods in [CapabilityStore].\n"]
2365#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2366#[repr(u32)]
2367pub enum CapabilityStoreError {
2368 IdNotFound = 1,
2369 IdAlreadyExists = 2,
2370 BadCapability = 3,
2371 WrongType = 4,
2372 NotDuplicatable = 5,
2373 ItemNotFound = 6,
2374 ItemAlreadyExists = 7,
2375 InvalidKey = 8,
2376 InvalidArgs = 9,
2377 UnknownOrdinal_(u32) = 10,
2378}
2379
2380impl ::fidl_next::Encodable for CapabilityStoreError {
2381 type Encoded = WireCapabilityStoreError;
2382}
2383impl ::std::convert::From<u32> for CapabilityStoreError {
2384 fn from(value: u32) -> Self {
2385 match value {
2386 1 => Self::IdNotFound,
2387 2 => Self::IdAlreadyExists,
2388 3 => Self::BadCapability,
2389 4 => Self::WrongType,
2390 5 => Self::NotDuplicatable,
2391 6 => Self::ItemNotFound,
2392 7 => Self::ItemAlreadyExists,
2393 8 => Self::InvalidKey,
2394 9 => Self::InvalidArgs,
2395
2396 _ => Self::UnknownOrdinal_(value),
2397 }
2398 }
2399}
2400
2401unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreError
2402where
2403 ___E: ?Sized,
2404{
2405 #[inline]
2406 fn encode(
2407 self,
2408 encoder: &mut ___E,
2409 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2410 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2411 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
2412 }
2413}
2414
2415unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreError
2416where
2417 ___E: ?Sized,
2418{
2419 #[inline]
2420 fn encode_ref(
2421 &self,
2422 encoder: &mut ___E,
2423 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2424 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2425 ::fidl_next::munge!(let WireCapabilityStoreError { value } = out);
2426 let _ = value.write(::fidl_next::WireU32::from(match *self {
2427 Self::IdNotFound => 1,
2428
2429 Self::IdAlreadyExists => 2,
2430
2431 Self::BadCapability => 3,
2432
2433 Self::WrongType => 4,
2434
2435 Self::NotDuplicatable => 5,
2436
2437 Self::ItemNotFound => 6,
2438
2439 Self::ItemAlreadyExists => 7,
2440
2441 Self::InvalidKey => 8,
2442
2443 Self::InvalidArgs => 9,
2444
2445 Self::UnknownOrdinal_(value) => value,
2446 }));
2447
2448 Ok(())
2449 }
2450}
2451
2452impl ::core::convert::From<WireCapabilityStoreError> for CapabilityStoreError {
2453 fn from(wire: WireCapabilityStoreError) -> Self {
2454 match u32::from(wire.value) {
2455 1 => Self::IdNotFound,
2456
2457 2 => Self::IdAlreadyExists,
2458
2459 3 => Self::BadCapability,
2460
2461 4 => Self::WrongType,
2462
2463 5 => Self::NotDuplicatable,
2464
2465 6 => Self::ItemNotFound,
2466
2467 7 => Self::ItemAlreadyExists,
2468
2469 8 => Self::InvalidKey,
2470
2471 9 => Self::InvalidArgs,
2472
2473 value => Self::UnknownOrdinal_(value),
2474 }
2475 }
2476}
2477
2478impl ::fidl_next::FromWire<WireCapabilityStoreError> for CapabilityStoreError {
2479 #[inline]
2480 fn from_wire(wire: WireCapabilityStoreError) -> Self {
2481 Self::from(wire)
2482 }
2483}
2484
2485impl ::fidl_next::IntoNatural for WireCapabilityStoreError {
2486 type Natural = CapabilityStoreError;
2487}
2488
2489impl ::fidl_next::FromWireRef<WireCapabilityStoreError> for CapabilityStoreError {
2490 #[inline]
2491 fn from_wire_ref(wire: &WireCapabilityStoreError) -> Self {
2492 Self::from(*wire)
2493 }
2494}
2495
2496#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2498#[repr(transparent)]
2499pub struct WireCapabilityStoreError {
2500 value: ::fidl_next::WireU32,
2501}
2502
2503unsafe impl ::fidl_next::Wire for WireCapabilityStoreError {
2504 type Decoded<'de> = Self;
2505
2506 #[inline]
2507 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2508 }
2510}
2511
2512impl WireCapabilityStoreError {
2513 pub const ID_NOT_FOUND: WireCapabilityStoreError =
2514 WireCapabilityStoreError { value: ::fidl_next::WireU32(1) };
2515
2516 pub const ID_ALREADY_EXISTS: WireCapabilityStoreError =
2517 WireCapabilityStoreError { value: ::fidl_next::WireU32(2) };
2518
2519 pub const BAD_CAPABILITY: WireCapabilityStoreError =
2520 WireCapabilityStoreError { value: ::fidl_next::WireU32(3) };
2521
2522 pub const WRONG_TYPE: WireCapabilityStoreError =
2523 WireCapabilityStoreError { value: ::fidl_next::WireU32(4) };
2524
2525 pub const NOT_DUPLICATABLE: WireCapabilityStoreError =
2526 WireCapabilityStoreError { value: ::fidl_next::WireU32(5) };
2527
2528 pub const ITEM_NOT_FOUND: WireCapabilityStoreError =
2529 WireCapabilityStoreError { value: ::fidl_next::WireU32(6) };
2530
2531 pub const ITEM_ALREADY_EXISTS: WireCapabilityStoreError =
2532 WireCapabilityStoreError { value: ::fidl_next::WireU32(7) };
2533
2534 pub const INVALID_KEY: WireCapabilityStoreError =
2535 WireCapabilityStoreError { value: ::fidl_next::WireU32(8) };
2536
2537 pub const INVALID_ARGS: WireCapabilityStoreError =
2538 WireCapabilityStoreError { value: ::fidl_next::WireU32(9) };
2539}
2540
2541unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreError
2542where
2543 ___D: ?Sized,
2544{
2545 fn decode(
2546 slot: ::fidl_next::Slot<'_, Self>,
2547 _: &mut ___D,
2548 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2549 Ok(())
2550 }
2551}
2552
2553impl ::core::convert::From<CapabilityStoreError> for WireCapabilityStoreError {
2554 fn from(natural: CapabilityStoreError) -> Self {
2555 match natural {
2556 CapabilityStoreError::IdNotFound => WireCapabilityStoreError::ID_NOT_FOUND,
2557
2558 CapabilityStoreError::IdAlreadyExists => WireCapabilityStoreError::ID_ALREADY_EXISTS,
2559
2560 CapabilityStoreError::BadCapability => WireCapabilityStoreError::BAD_CAPABILITY,
2561
2562 CapabilityStoreError::WrongType => WireCapabilityStoreError::WRONG_TYPE,
2563
2564 CapabilityStoreError::NotDuplicatable => WireCapabilityStoreError::NOT_DUPLICATABLE,
2565
2566 CapabilityStoreError::ItemNotFound => WireCapabilityStoreError::ITEM_NOT_FOUND,
2567
2568 CapabilityStoreError::ItemAlreadyExists => {
2569 WireCapabilityStoreError::ITEM_ALREADY_EXISTS
2570 }
2571
2572 CapabilityStoreError::InvalidKey => WireCapabilityStoreError::INVALID_KEY,
2573
2574 CapabilityStoreError::InvalidArgs => WireCapabilityStoreError::INVALID_ARGS,
2575
2576 CapabilityStoreError::UnknownOrdinal_(value) => {
2577 WireCapabilityStoreError { value: ::fidl_next::WireU32::from(value) }
2578 }
2579 }
2580 }
2581}
2582
2583#[derive(PartialEq, Clone, Debug)]
2584#[repr(C)]
2585pub struct CapabilityStoreDropRequest {
2586 pub id: u64,
2587}
2588
2589impl ::fidl_next::Encodable for CapabilityStoreDropRequest {
2590 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCapabilityStoreDropRequest> = unsafe {
2591 ::fidl_next::CopyOptimization::enable_if(
2592 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2593 )
2594 };
2595
2596 type Encoded = WireCapabilityStoreDropRequest;
2597}
2598
2599unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest
2600where
2601 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2602{
2603 #[inline]
2604 fn encode(
2605 self,
2606 encoder_: &mut ___E,
2607 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2608 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2609 ::fidl_next::munge! {
2610 let Self::Encoded {
2611 id,
2612
2613 } = out_;
2614 }
2615
2616 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2617
2618 Ok(())
2619 }
2620}
2621
2622unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropRequest
2623where
2624 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2625{
2626 #[inline]
2627 fn encode_ref(
2628 &self,
2629 encoder_: &mut ___E,
2630 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2631 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2632 ::fidl_next::munge! {
2633 let Self::Encoded {
2634
2635 id,
2636
2637 } = out_;
2638 }
2639
2640 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2641
2642 Ok(())
2643 }
2644}
2645
2646impl ::fidl_next::EncodableOption for CapabilityStoreDropRequest {
2647 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDropRequest>;
2648}
2649
2650unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropRequest
2651where
2652 ___E: ::fidl_next::Encoder + ?Sized,
2653 CapabilityStoreDropRequest: ::fidl_next::Encode<___E>,
2654{
2655 #[inline]
2656 fn encode_option(
2657 this: ::core::option::Option<Self>,
2658 encoder: &mut ___E,
2659 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2660 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2661 if let Some(inner) = this {
2662 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2663 ::fidl_next::WireBox::encode_present(out);
2664 } else {
2665 ::fidl_next::WireBox::encode_absent(out);
2666 }
2667
2668 Ok(())
2669 }
2670}
2671
2672unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropRequest
2673where
2674 ___E: ::fidl_next::Encoder + ?Sized,
2675 CapabilityStoreDropRequest: ::fidl_next::EncodeRef<___E>,
2676{
2677 #[inline]
2678 fn encode_option_ref(
2679 this: ::core::option::Option<&Self>,
2680 encoder: &mut ___E,
2681 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2683 if let Some(inner) = this {
2684 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2685 ::fidl_next::WireBox::encode_present(out);
2686 } else {
2687 ::fidl_next::WireBox::encode_absent(out);
2688 }
2689
2690 Ok(())
2691 }
2692}
2693
2694impl ::fidl_next::FromWire<WireCapabilityStoreDropRequest> for CapabilityStoreDropRequest {
2695 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCapabilityStoreDropRequest, Self> = unsafe {
2696 ::fidl_next::CopyOptimization::enable_if(
2697 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2698 .is_enabled(),
2699 )
2700 };
2701
2702 #[inline]
2703 fn from_wire(wire: WireCapabilityStoreDropRequest) -> Self {
2704 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2705 }
2706}
2707
2708impl ::fidl_next::IntoNatural for WireCapabilityStoreDropRequest {
2709 type Natural = CapabilityStoreDropRequest;
2710}
2711
2712impl ::fidl_next::FromWireRef<WireCapabilityStoreDropRequest> for CapabilityStoreDropRequest {
2713 #[inline]
2714 fn from_wire_ref(wire: &WireCapabilityStoreDropRequest) -> Self {
2715 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2716 }
2717}
2718
2719#[derive(Clone, Debug)]
2721#[repr(C)]
2722pub struct WireCapabilityStoreDropRequest {
2723 pub id: ::fidl_next::WireU64,
2724}
2725static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreDropRequest>(), 8);
2726static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreDropRequest>(), 8);
2727
2728static_assertions::const_assert_eq!(std::mem::offset_of!(WireCapabilityStoreDropRequest, id), 0);
2729
2730unsafe impl ::fidl_next::Wire for WireCapabilityStoreDropRequest {
2731 type Decoded<'de> = WireCapabilityStoreDropRequest;
2732
2733 #[inline]
2734 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2735 ::fidl_next::munge! {
2736 let Self {
2737
2738 id,
2739
2740 } = &mut *out_;
2741 }
2742
2743 ::fidl_next::Wire::zero_padding(id);
2744 }
2745}
2746
2747unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDropRequest
2748where
2749 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2750{
2751 fn decode(
2752 slot_: ::fidl_next::Slot<'_, Self>,
2753 decoder_: &mut ___D,
2754 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2755 ::fidl_next::munge! {
2756 let Self {
2757
2758 mut id,
2759
2760 } = slot_;
2761 }
2762
2763 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2764
2765 Ok(())
2766 }
2767}
2768
2769pub type CapabilityStoreDropResponse = ();
2770
2771pub type WireCapabilityStoreDropResponse = ();
2773
2774#[derive(PartialEq, Clone, Debug)]
2775#[repr(C)]
2776pub struct CapabilityStoreExportRequest {
2777 pub id: u64,
2778}
2779
2780impl ::fidl_next::Encodable for CapabilityStoreExportRequest {
2781 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCapabilityStoreExportRequest> = unsafe {
2782 ::fidl_next::CopyOptimization::enable_if(
2783 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2784 )
2785 };
2786
2787 type Encoded = WireCapabilityStoreExportRequest;
2788}
2789
2790unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest
2791where
2792 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2793{
2794 #[inline]
2795 fn encode(
2796 self,
2797 encoder_: &mut ___E,
2798 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
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 Ok(())
2810 }
2811}
2812
2813unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreExportRequest
2814where
2815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2816{
2817 #[inline]
2818 fn encode_ref(
2819 &self,
2820 encoder_: &mut ___E,
2821 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2822 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2823 ::fidl_next::munge! {
2824 let Self::Encoded {
2825
2826 id,
2827
2828 } = out_;
2829 }
2830
2831 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2832
2833 Ok(())
2834 }
2835}
2836
2837impl ::fidl_next::EncodableOption for CapabilityStoreExportRequest {
2838 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreExportRequest>;
2839}
2840
2841unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportRequest
2842where
2843 ___E: ::fidl_next::Encoder + ?Sized,
2844 CapabilityStoreExportRequest: ::fidl_next::Encode<___E>,
2845{
2846 #[inline]
2847 fn encode_option(
2848 this: ::core::option::Option<Self>,
2849 encoder: &mut ___E,
2850 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2851 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2852 if let Some(inner) = this {
2853 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2854 ::fidl_next::WireBox::encode_present(out);
2855 } else {
2856 ::fidl_next::WireBox::encode_absent(out);
2857 }
2858
2859 Ok(())
2860 }
2861}
2862
2863unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreExportRequest
2864where
2865 ___E: ::fidl_next::Encoder + ?Sized,
2866 CapabilityStoreExportRequest: ::fidl_next::EncodeRef<___E>,
2867{
2868 #[inline]
2869 fn encode_option_ref(
2870 this: ::core::option::Option<&Self>,
2871 encoder: &mut ___E,
2872 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2873 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2874 if let Some(inner) = this {
2875 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2876 ::fidl_next::WireBox::encode_present(out);
2877 } else {
2878 ::fidl_next::WireBox::encode_absent(out);
2879 }
2880
2881 Ok(())
2882 }
2883}
2884
2885impl ::fidl_next::FromWire<WireCapabilityStoreExportRequest> for CapabilityStoreExportRequest {
2886 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCapabilityStoreExportRequest, Self> = unsafe {
2887 ::fidl_next::CopyOptimization::enable_if(
2888 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2889 .is_enabled(),
2890 )
2891 };
2892
2893 #[inline]
2894 fn from_wire(wire: WireCapabilityStoreExportRequest) -> Self {
2895 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2896 }
2897}
2898
2899impl ::fidl_next::IntoNatural for WireCapabilityStoreExportRequest {
2900 type Natural = CapabilityStoreExportRequest;
2901}
2902
2903impl ::fidl_next::FromWireRef<WireCapabilityStoreExportRequest> for CapabilityStoreExportRequest {
2904 #[inline]
2905 fn from_wire_ref(wire: &WireCapabilityStoreExportRequest) -> Self {
2906 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2907 }
2908}
2909
2910#[derive(Clone, Debug)]
2912#[repr(C)]
2913pub struct WireCapabilityStoreExportRequest {
2914 pub id: ::fidl_next::WireU64,
2915}
2916static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreExportRequest>(), 8);
2917static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreExportRequest>(), 8);
2918
2919static_assertions::const_assert_eq!(std::mem::offset_of!(WireCapabilityStoreExportRequest, id), 0);
2920
2921unsafe impl ::fidl_next::Wire for WireCapabilityStoreExportRequest {
2922 type Decoded<'de> = WireCapabilityStoreExportRequest;
2923
2924 #[inline]
2925 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2926 ::fidl_next::munge! {
2927 let Self {
2928
2929 id,
2930
2931 } = &mut *out_;
2932 }
2933
2934 ::fidl_next::Wire::zero_padding(id);
2935 }
2936}
2937
2938unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportRequest
2939where
2940 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2941{
2942 fn decode(
2943 slot_: ::fidl_next::Slot<'_, Self>,
2944 decoder_: &mut ___D,
2945 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2946 ::fidl_next::munge! {
2947 let Self {
2948
2949 mut id,
2950
2951 } = slot_;
2952 }
2953
2954 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2955
2956 Ok(())
2957 }
2958}
2959
2960pub type CapabilityStoreImportResponse = ();
2961
2962pub type WireCapabilityStoreImportResponse = ();
2964
2965#[derive(PartialEq, Debug)]
2966pub struct CapabilityStoreConnectorCreateRequest {
2967 pub id: u64,
2968
2969 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
2970}
2971
2972impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest {
2973 type Encoded = WireCapabilityStoreConnectorCreateRequest;
2974}
2975
2976unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateRequest
2977where
2978 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2979 ___E: ::fidl_next::fuchsia::HandleEncoder,
2980{
2981 #[inline]
2982 fn encode(
2983 self,
2984 encoder_: &mut ___E,
2985 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2986 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2987 ::fidl_next::munge! {
2988 let Self::Encoded {
2989 id,
2990 receiver,
2991
2992 } = out_;
2993 }
2994
2995 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2996
2997 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
2998
2999 Ok(())
3000 }
3001}
3002
3003impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateRequest {
3004 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreConnectorCreateRequest>;
3005}
3006
3007unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateRequest
3008where
3009 ___E: ::fidl_next::Encoder + ?Sized,
3010 CapabilityStoreConnectorCreateRequest: ::fidl_next::Encode<___E>,
3011{
3012 #[inline]
3013 fn encode_option(
3014 this: ::core::option::Option<Self>,
3015 encoder: &mut ___E,
3016 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3018 if let Some(inner) = this {
3019 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3020 ::fidl_next::WireBox::encode_present(out);
3021 } else {
3022 ::fidl_next::WireBox::encode_absent(out);
3023 }
3024
3025 Ok(())
3026 }
3027}
3028
3029impl ::fidl_next::FromWire<WireCapabilityStoreConnectorCreateRequest>
3030 for CapabilityStoreConnectorCreateRequest
3031{
3032 #[inline]
3033 fn from_wire(wire: WireCapabilityStoreConnectorCreateRequest) -> Self {
3034 Self {
3035 id: ::fidl_next::FromWire::from_wire(wire.id),
3036
3037 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
3038 }
3039 }
3040}
3041
3042impl ::fidl_next::IntoNatural for WireCapabilityStoreConnectorCreateRequest {
3043 type Natural = CapabilityStoreConnectorCreateRequest;
3044}
3045
3046#[derive(Debug)]
3048#[repr(C)]
3049pub struct WireCapabilityStoreConnectorCreateRequest {
3050 pub id: ::fidl_next::WireU64,
3051
3052 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
3053}
3054static_assertions::const_assert_eq!(
3055 std::mem::size_of::<WireCapabilityStoreConnectorCreateRequest>(),
3056 16
3057);
3058static_assertions::const_assert_eq!(
3059 std::mem::align_of::<WireCapabilityStoreConnectorCreateRequest>(),
3060 8
3061);
3062
3063static_assertions::const_assert_eq!(
3064 std::mem::offset_of!(WireCapabilityStoreConnectorCreateRequest, id),
3065 0
3066);
3067
3068static_assertions::const_assert_eq!(
3069 std::mem::offset_of!(WireCapabilityStoreConnectorCreateRequest, receiver),
3070 8
3071);
3072
3073unsafe impl ::fidl_next::Wire for WireCapabilityStoreConnectorCreateRequest {
3074 type Decoded<'de> = WireCapabilityStoreConnectorCreateRequest;
3075
3076 #[inline]
3077 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3078 ::fidl_next::munge! {
3079 let Self {
3080
3081 id,
3082 receiver,
3083
3084 } = &mut *out_;
3085 }
3086
3087 ::fidl_next::Wire::zero_padding(id);
3088
3089 ::fidl_next::Wire::zero_padding(receiver);
3090
3091 unsafe {
3092 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3093 }
3094 }
3095}
3096
3097unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorCreateRequest
3098where
3099 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3100 ___D: ::fidl_next::fuchsia::HandleDecoder,
3101{
3102 fn decode(
3103 slot_: ::fidl_next::Slot<'_, Self>,
3104 decoder_: &mut ___D,
3105 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3106 ::fidl_next::munge! {
3107 let Self {
3108
3109 mut id,
3110 mut receiver,
3111
3112 } = slot_;
3113 }
3114
3115 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3116
3117 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_)?;
3118
3119 Ok(())
3120 }
3121}
3122
3123pub type CapabilityStoreConnectorCreateResponse = ();
3124
3125pub type WireCapabilityStoreConnectorCreateResponse = ();
3127
3128#[derive(PartialEq, Debug)]
3129pub struct CapabilityStoreConnectorOpenRequest {
3130 pub id: u64,
3131
3132 pub server_end: ::fidl_next::fuchsia::zx::Channel,
3133}
3134
3135impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest {
3136 type Encoded = WireCapabilityStoreConnectorOpenRequest;
3137}
3138
3139unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest
3140where
3141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3142 ___E: ::fidl_next::fuchsia::HandleEncoder,
3143{
3144 #[inline]
3145 fn encode(
3146 self,
3147 encoder_: &mut ___E,
3148 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3149 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3150 ::fidl_next::munge! {
3151 let Self::Encoded {
3152 id,
3153 server_end,
3154
3155 } = out_;
3156 }
3157
3158 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3159
3160 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
3161
3162 Ok(())
3163 }
3164}
3165
3166impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenRequest {
3167 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreConnectorOpenRequest>;
3168}
3169
3170unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenRequest
3171where
3172 ___E: ::fidl_next::Encoder + ?Sized,
3173 CapabilityStoreConnectorOpenRequest: ::fidl_next::Encode<___E>,
3174{
3175 #[inline]
3176 fn encode_option(
3177 this: ::core::option::Option<Self>,
3178 encoder: &mut ___E,
3179 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3180 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3181 if let Some(inner) = this {
3182 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3183 ::fidl_next::WireBox::encode_present(out);
3184 } else {
3185 ::fidl_next::WireBox::encode_absent(out);
3186 }
3187
3188 Ok(())
3189 }
3190}
3191
3192impl ::fidl_next::FromWire<WireCapabilityStoreConnectorOpenRequest>
3193 for CapabilityStoreConnectorOpenRequest
3194{
3195 #[inline]
3196 fn from_wire(wire: WireCapabilityStoreConnectorOpenRequest) -> Self {
3197 Self {
3198 id: ::fidl_next::FromWire::from_wire(wire.id),
3199
3200 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3201 }
3202 }
3203}
3204
3205impl ::fidl_next::IntoNatural for WireCapabilityStoreConnectorOpenRequest {
3206 type Natural = CapabilityStoreConnectorOpenRequest;
3207}
3208
3209#[derive(Debug)]
3211#[repr(C)]
3212pub struct WireCapabilityStoreConnectorOpenRequest {
3213 pub id: ::fidl_next::WireU64,
3214
3215 pub server_end: ::fidl_next::fuchsia::WireChannel,
3216}
3217static_assertions::const_assert_eq!(
3218 std::mem::size_of::<WireCapabilityStoreConnectorOpenRequest>(),
3219 16
3220);
3221static_assertions::const_assert_eq!(
3222 std::mem::align_of::<WireCapabilityStoreConnectorOpenRequest>(),
3223 8
3224);
3225
3226static_assertions::const_assert_eq!(
3227 std::mem::offset_of!(WireCapabilityStoreConnectorOpenRequest, id),
3228 0
3229);
3230
3231static_assertions::const_assert_eq!(
3232 std::mem::offset_of!(WireCapabilityStoreConnectorOpenRequest, server_end),
3233 8
3234);
3235
3236unsafe impl ::fidl_next::Wire for WireCapabilityStoreConnectorOpenRequest {
3237 type Decoded<'de> = WireCapabilityStoreConnectorOpenRequest;
3238
3239 #[inline]
3240 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3241 ::fidl_next::munge! {
3242 let Self {
3243
3244 id,
3245 server_end,
3246
3247 } = &mut *out_;
3248 }
3249
3250 ::fidl_next::Wire::zero_padding(id);
3251
3252 ::fidl_next::Wire::zero_padding(server_end);
3253
3254 unsafe {
3255 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3256 }
3257 }
3258}
3259
3260unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorOpenRequest
3261where
3262 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3263 ___D: ::fidl_next::fuchsia::HandleDecoder,
3264{
3265 fn decode(
3266 slot_: ::fidl_next::Slot<'_, Self>,
3267 decoder_: &mut ___D,
3268 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3269 ::fidl_next::munge! {
3270 let Self {
3271
3272 mut id,
3273 mut server_end,
3274
3275 } = slot_;
3276 }
3277
3278 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3279
3280 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
3281
3282 Ok(())
3283 }
3284}
3285
3286pub type CapabilityStoreConnectorOpenResponse = ();
3287
3288pub type WireCapabilityStoreConnectorOpenResponse = ();
3290
3291pub type CapabilityStoreDirConnectorCreateResponse = ();
3292
3293pub type WireCapabilityStoreDirConnectorCreateResponse = ();
3295
3296pub type CapabilityStoreDirConnectorOpenResponse = ();
3297
3298pub type WireCapabilityStoreDirConnectorOpenResponse = ();
3300
3301#[derive(PartialEq, Clone, Debug)]
3302#[repr(C)]
3303pub struct CapabilityStoreDictionaryCreateRequest {
3304 pub id: u64,
3305}
3306
3307impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest {
3308 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3309 Self,
3310 WireCapabilityStoreDictionaryCreateRequest,
3311 > = unsafe {
3312 ::fidl_next::CopyOptimization::enable_if(
3313 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
3314 )
3315 };
3316
3317 type Encoded = WireCapabilityStoreDictionaryCreateRequest;
3318}
3319
3320unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest
3321where
3322 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3323{
3324 #[inline]
3325 fn encode(
3326 self,
3327 encoder_: &mut ___E,
3328 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3330 ::fidl_next::munge! {
3331 let Self::Encoded {
3332 id,
3333
3334 } = out_;
3335 }
3336
3337 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3338
3339 Ok(())
3340 }
3341}
3342
3343unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateRequest
3344where
3345 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3346{
3347 #[inline]
3348 fn encode_ref(
3349 &self,
3350 encoder_: &mut ___E,
3351 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3353 ::fidl_next::munge! {
3354 let Self::Encoded {
3355
3356 id,
3357
3358 } = out_;
3359 }
3360
3361 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
3362
3363 Ok(())
3364 }
3365}
3366
3367impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateRequest {
3368 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryCreateRequest>;
3369}
3370
3371unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateRequest
3372where
3373 ___E: ::fidl_next::Encoder + ?Sized,
3374 CapabilityStoreDictionaryCreateRequest: ::fidl_next::Encode<___E>,
3375{
3376 #[inline]
3377 fn encode_option(
3378 this: ::core::option::Option<Self>,
3379 encoder: &mut ___E,
3380 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3381 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3382 if let Some(inner) = this {
3383 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3384 ::fidl_next::WireBox::encode_present(out);
3385 } else {
3386 ::fidl_next::WireBox::encode_absent(out);
3387 }
3388
3389 Ok(())
3390 }
3391}
3392
3393unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateRequest
3394where
3395 ___E: ::fidl_next::Encoder + ?Sized,
3396 CapabilityStoreDictionaryCreateRequest: ::fidl_next::EncodeRef<___E>,
3397{
3398 #[inline]
3399 fn encode_option_ref(
3400 this: ::core::option::Option<&Self>,
3401 encoder: &mut ___E,
3402 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3404 if let Some(inner) = this {
3405 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3406 ::fidl_next::WireBox::encode_present(out);
3407 } else {
3408 ::fidl_next::WireBox::encode_absent(out);
3409 }
3410
3411 Ok(())
3412 }
3413}
3414
3415impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryCreateRequest>
3416 for CapabilityStoreDictionaryCreateRequest
3417{
3418 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3419 WireCapabilityStoreDictionaryCreateRequest,
3420 Self,
3421 > = unsafe {
3422 ::fidl_next::CopyOptimization::enable_if(
3423 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
3424 .is_enabled(),
3425 )
3426 };
3427
3428 #[inline]
3429 fn from_wire(wire: WireCapabilityStoreDictionaryCreateRequest) -> Self {
3430 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
3431 }
3432}
3433
3434impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryCreateRequest {
3435 type Natural = CapabilityStoreDictionaryCreateRequest;
3436}
3437
3438impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCreateRequest>
3439 for CapabilityStoreDictionaryCreateRequest
3440{
3441 #[inline]
3442 fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCreateRequest) -> Self {
3443 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
3444 }
3445}
3446
3447#[derive(Clone, Debug)]
3449#[repr(C)]
3450pub struct WireCapabilityStoreDictionaryCreateRequest {
3451 pub id: ::fidl_next::WireU64,
3452}
3453static_assertions::const_assert_eq!(
3454 std::mem::size_of::<WireCapabilityStoreDictionaryCreateRequest>(),
3455 8
3456);
3457static_assertions::const_assert_eq!(
3458 std::mem::align_of::<WireCapabilityStoreDictionaryCreateRequest>(),
3459 8
3460);
3461
3462static_assertions::const_assert_eq!(
3463 std::mem::offset_of!(WireCapabilityStoreDictionaryCreateRequest, id),
3464 0
3465);
3466
3467unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryCreateRequest {
3468 type Decoded<'de> = WireCapabilityStoreDictionaryCreateRequest;
3469
3470 #[inline]
3471 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3472 ::fidl_next::munge! {
3473 let Self {
3474
3475 id,
3476
3477 } = &mut *out_;
3478 }
3479
3480 ::fidl_next::Wire::zero_padding(id);
3481 }
3482}
3483
3484unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCreateRequest
3485where
3486 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3487{
3488 fn decode(
3489 slot_: ::fidl_next::Slot<'_, Self>,
3490 decoder_: &mut ___D,
3491 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3492 ::fidl_next::munge! {
3493 let Self {
3494
3495 mut id,
3496
3497 } = slot_;
3498 }
3499
3500 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3501
3502 Ok(())
3503 }
3504}
3505
3506pub type CapabilityStoreDictionaryCreateResponse = ();
3507
3508pub type WireCapabilityStoreDictionaryCreateResponse = ();
3510
3511#[derive(PartialEq, Debug)]
3512pub struct CapabilityStoreDictionaryLegacyImportRequest {
3513 pub id: u64,
3514
3515 pub client_end: ::fidl_next::fuchsia::zx::Channel,
3516}
3517
3518impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest {
3519 type Encoded = WireCapabilityStoreDictionaryLegacyImportRequest;
3520}
3521
3522unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportRequest
3523where
3524 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3525 ___E: ::fidl_next::fuchsia::HandleEncoder,
3526{
3527 #[inline]
3528 fn encode(
3529 self,
3530 encoder_: &mut ___E,
3531 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3533 ::fidl_next::munge! {
3534 let Self::Encoded {
3535 id,
3536 client_end,
3537
3538 } = out_;
3539 }
3540
3541 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3542
3543 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end)?;
3544
3545 Ok(())
3546 }
3547}
3548
3549impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportRequest {
3550 type EncodedOption =
3551 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryLegacyImportRequest>;
3552}
3553
3554unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportRequest
3555where
3556 ___E: ::fidl_next::Encoder + ?Sized,
3557 CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Encode<___E>,
3558{
3559 #[inline]
3560 fn encode_option(
3561 this: ::core::option::Option<Self>,
3562 encoder: &mut ___E,
3563 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3564 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3565 if let Some(inner) = this {
3566 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3567 ::fidl_next::WireBox::encode_present(out);
3568 } else {
3569 ::fidl_next::WireBox::encode_absent(out);
3570 }
3571
3572 Ok(())
3573 }
3574}
3575
3576impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyImportRequest>
3577 for CapabilityStoreDictionaryLegacyImportRequest
3578{
3579 #[inline]
3580 fn from_wire(wire: WireCapabilityStoreDictionaryLegacyImportRequest) -> Self {
3581 Self {
3582 id: ::fidl_next::FromWire::from_wire(wire.id),
3583
3584 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
3585 }
3586 }
3587}
3588
3589impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryLegacyImportRequest {
3590 type Natural = CapabilityStoreDictionaryLegacyImportRequest;
3591}
3592
3593#[derive(Debug)]
3595#[repr(C)]
3596pub struct WireCapabilityStoreDictionaryLegacyImportRequest {
3597 pub id: ::fidl_next::WireU64,
3598
3599 pub client_end: ::fidl_next::fuchsia::WireChannel,
3600}
3601static_assertions::const_assert_eq!(
3602 std::mem::size_of::<WireCapabilityStoreDictionaryLegacyImportRequest>(),
3603 16
3604);
3605static_assertions::const_assert_eq!(
3606 std::mem::align_of::<WireCapabilityStoreDictionaryLegacyImportRequest>(),
3607 8
3608);
3609
3610static_assertions::const_assert_eq!(
3611 std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyImportRequest, id),
3612 0
3613);
3614
3615static_assertions::const_assert_eq!(
3616 std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyImportRequest, client_end),
3617 8
3618);
3619
3620unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryLegacyImportRequest {
3621 type Decoded<'de> = WireCapabilityStoreDictionaryLegacyImportRequest;
3622
3623 #[inline]
3624 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3625 ::fidl_next::munge! {
3626 let Self {
3627
3628 id,
3629 client_end,
3630
3631 } = &mut *out_;
3632 }
3633
3634 ::fidl_next::Wire::zero_padding(id);
3635
3636 ::fidl_next::Wire::zero_padding(client_end);
3637
3638 unsafe {
3639 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3640 }
3641 }
3642}
3643
3644unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyImportRequest
3645where
3646 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3647 ___D: ::fidl_next::fuchsia::HandleDecoder,
3648{
3649 fn decode(
3650 slot_: ::fidl_next::Slot<'_, Self>,
3651 decoder_: &mut ___D,
3652 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3653 ::fidl_next::munge! {
3654 let Self {
3655
3656 mut id,
3657 mut client_end,
3658
3659 } = slot_;
3660 }
3661
3662 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3663
3664 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_)?;
3665
3666 Ok(())
3667 }
3668}
3669
3670pub type CapabilityStoreDictionaryLegacyImportResponse = ();
3671
3672pub type WireCapabilityStoreDictionaryLegacyImportResponse = ();
3674
3675#[derive(PartialEq, Debug)]
3676pub struct CapabilityStoreDictionaryLegacyExportRequest {
3677 pub id: u64,
3678
3679 pub server_end: ::fidl_next::fuchsia::zx::Channel,
3680}
3681
3682impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest {
3683 type Encoded = WireCapabilityStoreDictionaryLegacyExportRequest;
3684}
3685
3686unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportRequest
3687where
3688 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3689 ___E: ::fidl_next::fuchsia::HandleEncoder,
3690{
3691 #[inline]
3692 fn encode(
3693 self,
3694 encoder_: &mut ___E,
3695 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3696 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3697 ::fidl_next::munge! {
3698 let Self::Encoded {
3699 id,
3700 server_end,
3701
3702 } = out_;
3703 }
3704
3705 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3706
3707 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
3708
3709 Ok(())
3710 }
3711}
3712
3713impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportRequest {
3714 type EncodedOption =
3715 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryLegacyExportRequest>;
3716}
3717
3718unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportRequest
3719where
3720 ___E: ::fidl_next::Encoder + ?Sized,
3721 CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Encode<___E>,
3722{
3723 #[inline]
3724 fn encode_option(
3725 this: ::core::option::Option<Self>,
3726 encoder: &mut ___E,
3727 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3728 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3729 if let Some(inner) = this {
3730 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3731 ::fidl_next::WireBox::encode_present(out);
3732 } else {
3733 ::fidl_next::WireBox::encode_absent(out);
3734 }
3735
3736 Ok(())
3737 }
3738}
3739
3740impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyExportRequest>
3741 for CapabilityStoreDictionaryLegacyExportRequest
3742{
3743 #[inline]
3744 fn from_wire(wire: WireCapabilityStoreDictionaryLegacyExportRequest) -> Self {
3745 Self {
3746 id: ::fidl_next::FromWire::from_wire(wire.id),
3747
3748 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3749 }
3750 }
3751}
3752
3753impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryLegacyExportRequest {
3754 type Natural = CapabilityStoreDictionaryLegacyExportRequest;
3755}
3756
3757#[derive(Debug)]
3759#[repr(C)]
3760pub struct WireCapabilityStoreDictionaryLegacyExportRequest {
3761 pub id: ::fidl_next::WireU64,
3762
3763 pub server_end: ::fidl_next::fuchsia::WireChannel,
3764}
3765static_assertions::const_assert_eq!(
3766 std::mem::size_of::<WireCapabilityStoreDictionaryLegacyExportRequest>(),
3767 16
3768);
3769static_assertions::const_assert_eq!(
3770 std::mem::align_of::<WireCapabilityStoreDictionaryLegacyExportRequest>(),
3771 8
3772);
3773
3774static_assertions::const_assert_eq!(
3775 std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyExportRequest, id),
3776 0
3777);
3778
3779static_assertions::const_assert_eq!(
3780 std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyExportRequest, server_end),
3781 8
3782);
3783
3784unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryLegacyExportRequest {
3785 type Decoded<'de> = WireCapabilityStoreDictionaryLegacyExportRequest;
3786
3787 #[inline]
3788 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3789 ::fidl_next::munge! {
3790 let Self {
3791
3792 id,
3793 server_end,
3794
3795 } = &mut *out_;
3796 }
3797
3798 ::fidl_next::Wire::zero_padding(id);
3799
3800 ::fidl_next::Wire::zero_padding(server_end);
3801
3802 unsafe {
3803 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3804 }
3805 }
3806}
3807
3808unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyExportRequest
3809where
3810 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3811 ___D: ::fidl_next::fuchsia::HandleDecoder,
3812{
3813 fn decode(
3814 slot_: ::fidl_next::Slot<'_, Self>,
3815 decoder_: &mut ___D,
3816 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3817 ::fidl_next::munge! {
3818 let Self {
3819
3820 mut id,
3821 mut server_end,
3822
3823 } = slot_;
3824 }
3825
3826 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3827
3828 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
3829
3830 Ok(())
3831 }
3832}
3833
3834pub type CapabilityStoreDictionaryLegacyExportResponse = ();
3835
3836pub type WireCapabilityStoreDictionaryLegacyExportResponse = ();
3838
3839#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
3840pub const MAX_NAME_LENGTH: u64 = 255 as u64;
3841
3842#[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
3843pub type DictionaryKey = ::std::string::String;
3844
3845pub type WireDictionaryKey<'de> = ::fidl_next::WireString<'de>;
3847
3848#[doc = " A key-value pair in a [`DictionaryRef`].\n"]
3849#[derive(PartialEq, Clone, Debug)]
3850pub struct DictionaryItem {
3851 pub key: ::std::string::String,
3852
3853 pub value: u64,
3854}
3855
3856impl ::fidl_next::Encodable for DictionaryItem {
3857 type Encoded = WireDictionaryItem<'static>;
3858}
3859
3860unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryItem
3861where
3862 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3863 ___E: ::fidl_next::Encoder,
3864{
3865 #[inline]
3866 fn encode(
3867 self,
3868 encoder_: &mut ___E,
3869 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3870 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3871 ::fidl_next::munge! {
3872 let Self::Encoded {
3873 key,
3874 value,
3875
3876 } = out_;
3877 }
3878
3879 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
3880
3881 ::fidl_next::Encode::encode(self.value, encoder_, value)?;
3882
3883 Ok(())
3884 }
3885}
3886
3887unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryItem
3888where
3889 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3890 ___E: ::fidl_next::Encoder,
3891{
3892 #[inline]
3893 fn encode_ref(
3894 &self,
3895 encoder_: &mut ___E,
3896 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3898 ::fidl_next::munge! {
3899 let Self::Encoded {
3900
3901 key,
3902 value,
3903
3904 } = out_;
3905 }
3906
3907 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
3908
3909 ::fidl_next::EncodeRef::encode_ref(&self.value, encoder_, value)?;
3910
3911 Ok(())
3912 }
3913}
3914
3915impl ::fidl_next::EncodableOption for DictionaryItem {
3916 type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryItem<'static>>;
3917}
3918
3919unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryItem
3920where
3921 ___E: ::fidl_next::Encoder + ?Sized,
3922 DictionaryItem: ::fidl_next::Encode<___E>,
3923{
3924 #[inline]
3925 fn encode_option(
3926 this: ::core::option::Option<Self>,
3927 encoder: &mut ___E,
3928 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3929 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3930 if let Some(inner) = this {
3931 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3932 ::fidl_next::WireBox::encode_present(out);
3933 } else {
3934 ::fidl_next::WireBox::encode_absent(out);
3935 }
3936
3937 Ok(())
3938 }
3939}
3940
3941unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryItem
3942where
3943 ___E: ::fidl_next::Encoder + ?Sized,
3944 DictionaryItem: ::fidl_next::EncodeRef<___E>,
3945{
3946 #[inline]
3947 fn encode_option_ref(
3948 this: ::core::option::Option<&Self>,
3949 encoder: &mut ___E,
3950 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3951 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3952 if let Some(inner) = this {
3953 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3954 ::fidl_next::WireBox::encode_present(out);
3955 } else {
3956 ::fidl_next::WireBox::encode_absent(out);
3957 }
3958
3959 Ok(())
3960 }
3961}
3962
3963impl<'de> ::fidl_next::FromWire<WireDictionaryItem<'de>> for DictionaryItem {
3964 #[inline]
3965 fn from_wire(wire: WireDictionaryItem<'de>) -> Self {
3966 Self {
3967 key: ::fidl_next::FromWire::from_wire(wire.key),
3968
3969 value: ::fidl_next::FromWire::from_wire(wire.value),
3970 }
3971 }
3972}
3973
3974impl<'de> ::fidl_next::IntoNatural for WireDictionaryItem<'de> {
3975 type Natural = DictionaryItem;
3976}
3977
3978impl<'de> ::fidl_next::FromWireRef<WireDictionaryItem<'de>> for DictionaryItem {
3979 #[inline]
3980 fn from_wire_ref(wire: &WireDictionaryItem<'de>) -> Self {
3981 Self {
3982 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3983
3984 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
3985 }
3986 }
3987}
3988
3989#[derive(Debug)]
3991#[repr(C)]
3992pub struct WireDictionaryItem<'de> {
3993 pub key: ::fidl_next::WireString<'de>,
3994
3995 pub value: ::fidl_next::WireU64,
3996}
3997static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryItem<'_>>(), 24);
3998static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryItem<'_>>(), 8);
3999
4000static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryItem<'_>, key), 0);
4001
4002static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryItem<'_>, value), 16);
4003
4004unsafe impl ::fidl_next::Wire for WireDictionaryItem<'static> {
4005 type Decoded<'de> = WireDictionaryItem<'de>;
4006
4007 #[inline]
4008 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4009 ::fidl_next::munge! {
4010 let Self {
4011
4012 key,
4013 value,
4014
4015 } = &mut *out_;
4016 }
4017
4018 ::fidl_next::Wire::zero_padding(key);
4019
4020 ::fidl_next::Wire::zero_padding(value);
4021 }
4022}
4023
4024unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryItem<'static>
4025where
4026 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4027 ___D: ::fidl_next::Decoder,
4028{
4029 fn decode(
4030 slot_: ::fidl_next::Slot<'_, Self>,
4031 decoder_: &mut ___D,
4032 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4033 ::fidl_next::munge! {
4034 let Self {
4035
4036 mut key,
4037 mut value,
4038
4039 } = slot_;
4040 }
4041
4042 ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4043
4044 let key = unsafe { key.deref_unchecked() };
4045
4046 if key.len() > 255 {
4047 return Err(::fidl_next::DecodeError::VectorTooLong {
4048 size: key.len() as u64,
4049 limit: 255,
4050 });
4051 }
4052
4053 ::fidl_next::Decode::decode(value.as_mut(), decoder_)?;
4054
4055 Ok(())
4056 }
4057}
4058
4059#[derive(PartialEq, Clone, Debug)]
4060pub struct CapabilityStoreDictionaryInsertRequest {
4061 pub id: u64,
4062
4063 pub item: crate::DictionaryItem,
4064}
4065
4066impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest {
4067 type Encoded = WireCapabilityStoreDictionaryInsertRequest<'static>;
4068}
4069
4070unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertRequest
4071where
4072 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4073 ___E: ::fidl_next::Encoder,
4074{
4075 #[inline]
4076 fn encode(
4077 self,
4078 encoder_: &mut ___E,
4079 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4080 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4081 ::fidl_next::munge! {
4082 let Self::Encoded {
4083 id,
4084 item,
4085
4086 } = out_;
4087 }
4088
4089 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4090
4091 ::fidl_next::Encode::encode(self.item, encoder_, item)?;
4092
4093 Ok(())
4094 }
4095}
4096
4097unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertRequest
4098where
4099 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4100 ___E: ::fidl_next::Encoder,
4101{
4102 #[inline]
4103 fn encode_ref(
4104 &self,
4105 encoder_: &mut ___E,
4106 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4107 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4108 ::fidl_next::munge! {
4109 let Self::Encoded {
4110
4111 id,
4112 item,
4113
4114 } = out_;
4115 }
4116
4117 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4118
4119 ::fidl_next::EncodeRef::encode_ref(&self.item, encoder_, item)?;
4120
4121 Ok(())
4122 }
4123}
4124
4125impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertRequest {
4126 type EncodedOption =
4127 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryInsertRequest<'static>>;
4128}
4129
4130unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertRequest
4131where
4132 ___E: ::fidl_next::Encoder + ?Sized,
4133 CapabilityStoreDictionaryInsertRequest: ::fidl_next::Encode<___E>,
4134{
4135 #[inline]
4136 fn encode_option(
4137 this: ::core::option::Option<Self>,
4138 encoder: &mut ___E,
4139 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4140 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4141 if let Some(inner) = this {
4142 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4143 ::fidl_next::WireBox::encode_present(out);
4144 } else {
4145 ::fidl_next::WireBox::encode_absent(out);
4146 }
4147
4148 Ok(())
4149 }
4150}
4151
4152unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertRequest
4153where
4154 ___E: ::fidl_next::Encoder + ?Sized,
4155 CapabilityStoreDictionaryInsertRequest: ::fidl_next::EncodeRef<___E>,
4156{
4157 #[inline]
4158 fn encode_option_ref(
4159 this: ::core::option::Option<&Self>,
4160 encoder: &mut ___E,
4161 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4162 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4163 if let Some(inner) = this {
4164 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4165 ::fidl_next::WireBox::encode_present(out);
4166 } else {
4167 ::fidl_next::WireBox::encode_absent(out);
4168 }
4169
4170 Ok(())
4171 }
4172}
4173
4174impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryInsertRequest<'de>>
4175 for CapabilityStoreDictionaryInsertRequest
4176{
4177 #[inline]
4178 fn from_wire(wire: WireCapabilityStoreDictionaryInsertRequest<'de>) -> Self {
4179 Self {
4180 id: ::fidl_next::FromWire::from_wire(wire.id),
4181
4182 item: ::fidl_next::FromWire::from_wire(wire.item),
4183 }
4184 }
4185}
4186
4187impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryInsertRequest<'de> {
4188 type Natural = CapabilityStoreDictionaryInsertRequest;
4189}
4190
4191impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryInsertRequest<'de>>
4192 for CapabilityStoreDictionaryInsertRequest
4193{
4194 #[inline]
4195 fn from_wire_ref(wire: &WireCapabilityStoreDictionaryInsertRequest<'de>) -> Self {
4196 Self {
4197 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4198
4199 item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
4200 }
4201 }
4202}
4203
4204#[derive(Debug)]
4206#[repr(C)]
4207pub struct WireCapabilityStoreDictionaryInsertRequest<'de> {
4208 pub id: ::fidl_next::WireU64,
4209
4210 pub item: crate::WireDictionaryItem<'de>,
4211}
4212static_assertions::const_assert_eq!(
4213 std::mem::size_of::<WireCapabilityStoreDictionaryInsertRequest<'_>>(),
4214 32
4215);
4216static_assertions::const_assert_eq!(
4217 std::mem::align_of::<WireCapabilityStoreDictionaryInsertRequest<'_>>(),
4218 8
4219);
4220
4221static_assertions::const_assert_eq!(
4222 std::mem::offset_of!(WireCapabilityStoreDictionaryInsertRequest<'_>, id),
4223 0
4224);
4225
4226static_assertions::const_assert_eq!(
4227 std::mem::offset_of!(WireCapabilityStoreDictionaryInsertRequest<'_>, item),
4228 8
4229);
4230
4231unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryInsertRequest<'static> {
4232 type Decoded<'de> = WireCapabilityStoreDictionaryInsertRequest<'de>;
4233
4234 #[inline]
4235 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4236 ::fidl_next::munge! {
4237 let Self {
4238
4239 id,
4240 item,
4241
4242 } = &mut *out_;
4243 }
4244
4245 ::fidl_next::Wire::zero_padding(id);
4246
4247 ::fidl_next::Wire::zero_padding(item);
4248 }
4249}
4250
4251unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryInsertRequest<'static>
4252where
4253 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4254 ___D: ::fidl_next::Decoder,
4255{
4256 fn decode(
4257 slot_: ::fidl_next::Slot<'_, Self>,
4258 decoder_: &mut ___D,
4259 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4260 ::fidl_next::munge! {
4261 let Self {
4262
4263 mut id,
4264 mut item,
4265
4266 } = slot_;
4267 }
4268
4269 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4270
4271 ::fidl_next::Decode::decode(item.as_mut(), decoder_)?;
4272
4273 Ok(())
4274 }
4275}
4276
4277pub type CapabilityStoreDictionaryInsertResponse = ();
4278
4279pub type WireCapabilityStoreDictionaryInsertResponse = ();
4281
4282#[derive(PartialEq, Clone, Debug)]
4283pub struct CapabilityStoreDictionaryGetRequest {
4284 pub id: u64,
4285
4286 pub key: ::std::string::String,
4287
4288 pub dest_id: u64,
4289}
4290
4291impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest {
4292 type Encoded = WireCapabilityStoreDictionaryGetRequest<'static>;
4293}
4294
4295unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetRequest
4296where
4297 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4298 ___E: ::fidl_next::Encoder,
4299{
4300 #[inline]
4301 fn encode(
4302 self,
4303 encoder_: &mut ___E,
4304 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4305 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4306 ::fidl_next::munge! {
4307 let Self::Encoded {
4308 id,
4309 key,
4310 dest_id,
4311
4312 } = out_;
4313 }
4314
4315 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4316
4317 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
4318
4319 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
4320
4321 Ok(())
4322 }
4323}
4324
4325unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetRequest
4326where
4327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4328 ___E: ::fidl_next::Encoder,
4329{
4330 #[inline]
4331 fn encode_ref(
4332 &self,
4333 encoder_: &mut ___E,
4334 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4335 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4336 ::fidl_next::munge! {
4337 let Self::Encoded {
4338
4339 id,
4340 key,
4341 dest_id,
4342
4343 } = out_;
4344 }
4345
4346 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4347
4348 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
4349
4350 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
4351
4352 Ok(())
4353 }
4354}
4355
4356impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetRequest {
4357 type EncodedOption =
4358 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryGetRequest<'static>>;
4359}
4360
4361unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetRequest
4362where
4363 ___E: ::fidl_next::Encoder + ?Sized,
4364 CapabilityStoreDictionaryGetRequest: ::fidl_next::Encode<___E>,
4365{
4366 #[inline]
4367 fn encode_option(
4368 this: ::core::option::Option<Self>,
4369 encoder: &mut ___E,
4370 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4371 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4372 if let Some(inner) = this {
4373 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4374 ::fidl_next::WireBox::encode_present(out);
4375 } else {
4376 ::fidl_next::WireBox::encode_absent(out);
4377 }
4378
4379 Ok(())
4380 }
4381}
4382
4383unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetRequest
4384where
4385 ___E: ::fidl_next::Encoder + ?Sized,
4386 CapabilityStoreDictionaryGetRequest: ::fidl_next::EncodeRef<___E>,
4387{
4388 #[inline]
4389 fn encode_option_ref(
4390 this: ::core::option::Option<&Self>,
4391 encoder: &mut ___E,
4392 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4393 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4394 if let Some(inner) = this {
4395 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4396 ::fidl_next::WireBox::encode_present(out);
4397 } else {
4398 ::fidl_next::WireBox::encode_absent(out);
4399 }
4400
4401 Ok(())
4402 }
4403}
4404
4405impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryGetRequest<'de>>
4406 for CapabilityStoreDictionaryGetRequest
4407{
4408 #[inline]
4409 fn from_wire(wire: WireCapabilityStoreDictionaryGetRequest<'de>) -> Self {
4410 Self {
4411 id: ::fidl_next::FromWire::from_wire(wire.id),
4412
4413 key: ::fidl_next::FromWire::from_wire(wire.key),
4414
4415 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4416 }
4417 }
4418}
4419
4420impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryGetRequest<'de> {
4421 type Natural = CapabilityStoreDictionaryGetRequest;
4422}
4423
4424impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryGetRequest<'de>>
4425 for CapabilityStoreDictionaryGetRequest
4426{
4427 #[inline]
4428 fn from_wire_ref(wire: &WireCapabilityStoreDictionaryGetRequest<'de>) -> Self {
4429 Self {
4430 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4431
4432 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4433
4434 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4435 }
4436 }
4437}
4438
4439#[derive(Debug)]
4441#[repr(C)]
4442pub struct WireCapabilityStoreDictionaryGetRequest<'de> {
4443 pub id: ::fidl_next::WireU64,
4444
4445 pub key: ::fidl_next::WireString<'de>,
4446
4447 pub dest_id: ::fidl_next::WireU64,
4448}
4449static_assertions::const_assert_eq!(
4450 std::mem::size_of::<WireCapabilityStoreDictionaryGetRequest<'_>>(),
4451 32
4452);
4453static_assertions::const_assert_eq!(
4454 std::mem::align_of::<WireCapabilityStoreDictionaryGetRequest<'_>>(),
4455 8
4456);
4457
4458static_assertions::const_assert_eq!(
4459 std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, id),
4460 0
4461);
4462
4463static_assertions::const_assert_eq!(
4464 std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, key),
4465 8
4466);
4467
4468static_assertions::const_assert_eq!(
4469 std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, dest_id),
4470 24
4471);
4472
4473unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryGetRequest<'static> {
4474 type Decoded<'de> = WireCapabilityStoreDictionaryGetRequest<'de>;
4475
4476 #[inline]
4477 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4478 ::fidl_next::munge! {
4479 let Self {
4480
4481 id,
4482 key,
4483 dest_id,
4484
4485 } = &mut *out_;
4486 }
4487
4488 ::fidl_next::Wire::zero_padding(id);
4489
4490 ::fidl_next::Wire::zero_padding(key);
4491
4492 ::fidl_next::Wire::zero_padding(dest_id);
4493 }
4494}
4495
4496unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryGetRequest<'static>
4497where
4498 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4499 ___D: ::fidl_next::Decoder,
4500{
4501 fn decode(
4502 slot_: ::fidl_next::Slot<'_, Self>,
4503 decoder_: &mut ___D,
4504 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4505 ::fidl_next::munge! {
4506 let Self {
4507
4508 mut id,
4509 mut key,
4510 mut dest_id,
4511
4512 } = slot_;
4513 }
4514
4515 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4516
4517 ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4518
4519 let key = unsafe { key.deref_unchecked() };
4520
4521 if key.len() > 255 {
4522 return Err(::fidl_next::DecodeError::VectorTooLong {
4523 size: key.len() as u64,
4524 limit: 255,
4525 });
4526 }
4527
4528 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
4529
4530 Ok(())
4531 }
4532}
4533
4534pub type CapabilityStoreDictionaryGetResponse = ();
4535
4536pub type WireCapabilityStoreDictionaryGetResponse = ();
4538
4539#[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"]
4540#[derive(PartialEq, Clone, Debug)]
4541#[repr(C)]
4542pub struct WrappedCapabilityId {
4543 pub id: u64,
4544}
4545
4546impl ::fidl_next::Encodable for WrappedCapabilityId {
4547 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireWrappedCapabilityId> = unsafe {
4548 ::fidl_next::CopyOptimization::enable_if(
4549 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4550 )
4551 };
4552
4553 type Encoded = WireWrappedCapabilityId;
4554}
4555
4556unsafe impl<___E> ::fidl_next::Encode<___E> for WrappedCapabilityId
4557where
4558 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4559{
4560 #[inline]
4561 fn encode(
4562 self,
4563 encoder_: &mut ___E,
4564 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4565 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4566 ::fidl_next::munge! {
4567 let Self::Encoded {
4568 id,
4569
4570 } = out_;
4571 }
4572
4573 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4574
4575 Ok(())
4576 }
4577}
4578
4579unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WrappedCapabilityId
4580where
4581 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4582{
4583 #[inline]
4584 fn encode_ref(
4585 &self,
4586 encoder_: &mut ___E,
4587 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4589 ::fidl_next::munge! {
4590 let Self::Encoded {
4591
4592 id,
4593
4594 } = out_;
4595 }
4596
4597 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4598
4599 Ok(())
4600 }
4601}
4602
4603impl ::fidl_next::EncodableOption for WrappedCapabilityId {
4604 type EncodedOption = ::fidl_next::WireBox<'static, WireWrappedCapabilityId>;
4605}
4606
4607unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WrappedCapabilityId
4608where
4609 ___E: ::fidl_next::Encoder + ?Sized,
4610 WrappedCapabilityId: ::fidl_next::Encode<___E>,
4611{
4612 #[inline]
4613 fn encode_option(
4614 this: ::core::option::Option<Self>,
4615 encoder: &mut ___E,
4616 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4617 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4618 if let Some(inner) = this {
4619 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4620 ::fidl_next::WireBox::encode_present(out);
4621 } else {
4622 ::fidl_next::WireBox::encode_absent(out);
4623 }
4624
4625 Ok(())
4626 }
4627}
4628
4629unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WrappedCapabilityId
4630where
4631 ___E: ::fidl_next::Encoder + ?Sized,
4632 WrappedCapabilityId: ::fidl_next::EncodeRef<___E>,
4633{
4634 #[inline]
4635 fn encode_option_ref(
4636 this: ::core::option::Option<&Self>,
4637 encoder: &mut ___E,
4638 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4639 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4640 if let Some(inner) = this {
4641 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4642 ::fidl_next::WireBox::encode_present(out);
4643 } else {
4644 ::fidl_next::WireBox::encode_absent(out);
4645 }
4646
4647 Ok(())
4648 }
4649}
4650
4651impl ::fidl_next::FromWire<WireWrappedCapabilityId> for WrappedCapabilityId {
4652 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireWrappedCapabilityId, Self> = unsafe {
4653 ::fidl_next::CopyOptimization::enable_if(
4654 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4655 .is_enabled(),
4656 )
4657 };
4658
4659 #[inline]
4660 fn from_wire(wire: WireWrappedCapabilityId) -> Self {
4661 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
4662 }
4663}
4664
4665impl ::fidl_next::IntoNatural for WireWrappedCapabilityId {
4666 type Natural = WrappedCapabilityId;
4667}
4668
4669impl ::fidl_next::FromWireRef<WireWrappedCapabilityId> for WrappedCapabilityId {
4670 #[inline]
4671 fn from_wire_ref(wire: &WireWrappedCapabilityId) -> Self {
4672 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
4673 }
4674}
4675
4676#[derive(Clone, Debug)]
4678#[repr(C)]
4679pub struct WireWrappedCapabilityId {
4680 pub id: ::fidl_next::WireU64,
4681}
4682static_assertions::const_assert_eq!(std::mem::size_of::<WireWrappedCapabilityId>(), 8);
4683static_assertions::const_assert_eq!(std::mem::align_of::<WireWrappedCapabilityId>(), 8);
4684
4685static_assertions::const_assert_eq!(std::mem::offset_of!(WireWrappedCapabilityId, id), 0);
4686
4687unsafe impl ::fidl_next::Wire for WireWrappedCapabilityId {
4688 type Decoded<'de> = WireWrappedCapabilityId;
4689
4690 #[inline]
4691 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4692 ::fidl_next::munge! {
4693 let Self {
4694
4695 id,
4696
4697 } = &mut *out_;
4698 }
4699
4700 ::fidl_next::Wire::zero_padding(id);
4701 }
4702}
4703
4704unsafe impl<___D> ::fidl_next::Decode<___D> for WireWrappedCapabilityId
4705where
4706 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4707{
4708 fn decode(
4709 slot_: ::fidl_next::Slot<'_, Self>,
4710 decoder_: &mut ___D,
4711 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4712 ::fidl_next::munge! {
4713 let Self {
4714
4715 mut id,
4716
4717 } = slot_;
4718 }
4719
4720 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4721
4722 Ok(())
4723 }
4724}
4725
4726pub type WrappedNewCapabilityId = crate::WrappedCapabilityId;
4727
4728pub type WireWrappedNewCapabilityId = crate::WireWrappedCapabilityId;
4730
4731#[derive(PartialEq, Clone, Debug)]
4732pub struct CapabilityStoreDictionaryRemoveRequest {
4733 pub id: u64,
4734
4735 pub key: ::std::string::String,
4736
4737 pub dest_id: ::core::option::Option<::std::boxed::Box<crate::WrappedCapabilityId>>,
4738}
4739
4740impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest {
4741 type Encoded = WireCapabilityStoreDictionaryRemoveRequest<'static>;
4742}
4743
4744unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveRequest
4745where
4746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4747 ___E: ::fidl_next::Encoder,
4748{
4749 #[inline]
4750 fn encode(
4751 self,
4752 encoder_: &mut ___E,
4753 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4754 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4755 ::fidl_next::munge! {
4756 let Self::Encoded {
4757 id,
4758 key,
4759 dest_id,
4760
4761 } = out_;
4762 }
4763
4764 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4765
4766 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
4767
4768 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
4769
4770 Ok(())
4771 }
4772}
4773
4774unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveRequest
4775where
4776 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4777 ___E: ::fidl_next::Encoder,
4778{
4779 #[inline]
4780 fn encode_ref(
4781 &self,
4782 encoder_: &mut ___E,
4783 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4784 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4785 ::fidl_next::munge! {
4786 let Self::Encoded {
4787
4788 id,
4789 key,
4790 dest_id,
4791
4792 } = out_;
4793 }
4794
4795 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4796
4797 ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
4798
4799 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
4800
4801 Ok(())
4802 }
4803}
4804
4805impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveRequest {
4806 type EncodedOption =
4807 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryRemoveRequest<'static>>;
4808}
4809
4810unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveRequest
4811where
4812 ___E: ::fidl_next::Encoder + ?Sized,
4813 CapabilityStoreDictionaryRemoveRequest: ::fidl_next::Encode<___E>,
4814{
4815 #[inline]
4816 fn encode_option(
4817 this: ::core::option::Option<Self>,
4818 encoder: &mut ___E,
4819 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4820 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4821 if let Some(inner) = this {
4822 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4823 ::fidl_next::WireBox::encode_present(out);
4824 } else {
4825 ::fidl_next::WireBox::encode_absent(out);
4826 }
4827
4828 Ok(())
4829 }
4830}
4831
4832unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveRequest
4833where
4834 ___E: ::fidl_next::Encoder + ?Sized,
4835 CapabilityStoreDictionaryRemoveRequest: ::fidl_next::EncodeRef<___E>,
4836{
4837 #[inline]
4838 fn encode_option_ref(
4839 this: ::core::option::Option<&Self>,
4840 encoder: &mut ___E,
4841 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4842 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4843 if let Some(inner) = this {
4844 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4845 ::fidl_next::WireBox::encode_present(out);
4846 } else {
4847 ::fidl_next::WireBox::encode_absent(out);
4848 }
4849
4850 Ok(())
4851 }
4852}
4853
4854impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryRemoveRequest<'de>>
4855 for CapabilityStoreDictionaryRemoveRequest
4856{
4857 #[inline]
4858 fn from_wire(wire: WireCapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4859 Self {
4860 id: ::fidl_next::FromWire::from_wire(wire.id),
4861
4862 key: ::fidl_next::FromWire::from_wire(wire.key),
4863
4864 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4865 }
4866 }
4867}
4868
4869impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryRemoveRequest<'de> {
4870 type Natural = CapabilityStoreDictionaryRemoveRequest;
4871}
4872
4873impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryRemoveRequest<'de>>
4874 for CapabilityStoreDictionaryRemoveRequest
4875{
4876 #[inline]
4877 fn from_wire_ref(wire: &WireCapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4878 Self {
4879 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4880
4881 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4882
4883 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4884 }
4885 }
4886}
4887
4888#[derive(Debug)]
4890#[repr(C)]
4891pub struct WireCapabilityStoreDictionaryRemoveRequest<'de> {
4892 pub id: ::fidl_next::WireU64,
4893
4894 pub key: ::fidl_next::WireString<'de>,
4895
4896 pub dest_id: ::fidl_next::WireBox<'de, crate::WireWrappedCapabilityId>,
4897}
4898static_assertions::const_assert_eq!(
4899 std::mem::size_of::<WireCapabilityStoreDictionaryRemoveRequest<'_>>(),
4900 32
4901);
4902static_assertions::const_assert_eq!(
4903 std::mem::align_of::<WireCapabilityStoreDictionaryRemoveRequest<'_>>(),
4904 8
4905);
4906
4907static_assertions::const_assert_eq!(
4908 std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, id),
4909 0
4910);
4911
4912static_assertions::const_assert_eq!(
4913 std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, key),
4914 8
4915);
4916
4917static_assertions::const_assert_eq!(
4918 std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
4919 24
4920);
4921
4922unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryRemoveRequest<'static> {
4923 type Decoded<'de> = WireCapabilityStoreDictionaryRemoveRequest<'de>;
4924
4925 #[inline]
4926 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4927 ::fidl_next::munge! {
4928 let Self {
4929
4930 id,
4931 key,
4932 dest_id,
4933
4934 } = &mut *out_;
4935 }
4936
4937 ::fidl_next::Wire::zero_padding(id);
4938
4939 ::fidl_next::Wire::zero_padding(key);
4940
4941 ::fidl_next::Wire::zero_padding(dest_id);
4942 }
4943}
4944
4945unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryRemoveRequest<'static>
4946where
4947 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4948 ___D: ::fidl_next::Decoder,
4949{
4950 fn decode(
4951 slot_: ::fidl_next::Slot<'_, Self>,
4952 decoder_: &mut ___D,
4953 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4954 ::fidl_next::munge! {
4955 let Self {
4956
4957 mut id,
4958 mut key,
4959 mut dest_id,
4960
4961 } = slot_;
4962 }
4963
4964 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4965
4966 ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4967
4968 let key = unsafe { key.deref_unchecked() };
4969
4970 if key.len() > 255 {
4971 return Err(::fidl_next::DecodeError::VectorTooLong {
4972 size: key.len() as u64,
4973 limit: 255,
4974 });
4975 }
4976
4977 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
4978
4979 Ok(())
4980 }
4981}
4982
4983pub type CapabilityStoreDictionaryRemoveResponse = ();
4984
4985pub type WireCapabilityStoreDictionaryRemoveResponse = ();
4987
4988#[derive(PartialEq, Clone, Debug)]
4989#[repr(C)]
4990pub struct CapabilityStoreDictionaryCopyRequest {
4991 pub id: u64,
4992
4993 pub dest_id: u64,
4994}
4995
4996impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest {
4997 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4998 Self,
4999 WireCapabilityStoreDictionaryCopyRequest,
5000 > = unsafe {
5001 ::fidl_next::CopyOptimization::enable_if(
5002 true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
5003 && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
5004 )
5005 };
5006
5007 type Encoded = WireCapabilityStoreDictionaryCopyRequest;
5008}
5009
5010unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest
5011where
5012 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5013{
5014 #[inline]
5015 fn encode(
5016 self,
5017 encoder_: &mut ___E,
5018 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5020 ::fidl_next::munge! {
5021 let Self::Encoded {
5022 id,
5023 dest_id,
5024
5025 } = out_;
5026 }
5027
5028 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5029
5030 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
5031
5032 Ok(())
5033 }
5034}
5035
5036unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyRequest
5037where
5038 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5039{
5040 #[inline]
5041 fn encode_ref(
5042 &self,
5043 encoder_: &mut ___E,
5044 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5045 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5046 ::fidl_next::munge! {
5047 let Self::Encoded {
5048
5049 id,
5050 dest_id,
5051
5052 } = out_;
5053 }
5054
5055 ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
5056
5057 ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
5058
5059 Ok(())
5060 }
5061}
5062
5063impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyRequest {
5064 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryCopyRequest>;
5065}
5066
5067unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyRequest
5068where
5069 ___E: ::fidl_next::Encoder + ?Sized,
5070 CapabilityStoreDictionaryCopyRequest: ::fidl_next::Encode<___E>,
5071{
5072 #[inline]
5073 fn encode_option(
5074 this: ::core::option::Option<Self>,
5075 encoder: &mut ___E,
5076 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5077 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5078 if let Some(inner) = this {
5079 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5080 ::fidl_next::WireBox::encode_present(out);
5081 } else {
5082 ::fidl_next::WireBox::encode_absent(out);
5083 }
5084
5085 Ok(())
5086 }
5087}
5088
5089unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyRequest
5090where
5091 ___E: ::fidl_next::Encoder + ?Sized,
5092 CapabilityStoreDictionaryCopyRequest: ::fidl_next::EncodeRef<___E>,
5093{
5094 #[inline]
5095 fn encode_option_ref(
5096 this: ::core::option::Option<&Self>,
5097 encoder: &mut ___E,
5098 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5099 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5100 if let Some(inner) = this {
5101 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5102 ::fidl_next::WireBox::encode_present(out);
5103 } else {
5104 ::fidl_next::WireBox::encode_absent(out);
5105 }
5106
5107 Ok(())
5108 }
5109}
5110
5111impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryCopyRequest>
5112 for CapabilityStoreDictionaryCopyRequest
5113{
5114 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5115 WireCapabilityStoreDictionaryCopyRequest,
5116 Self,
5117 > = unsafe {
5118 ::fidl_next::CopyOptimization::enable_if(
5119 true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
5120 .is_enabled()
5121 && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
5122 .is_enabled(),
5123 )
5124 };
5125
5126 #[inline]
5127 fn from_wire(wire: WireCapabilityStoreDictionaryCopyRequest) -> Self {
5128 Self {
5129 id: ::fidl_next::FromWire::from_wire(wire.id),
5130
5131 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
5132 }
5133 }
5134}
5135
5136impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryCopyRequest {
5137 type Natural = CapabilityStoreDictionaryCopyRequest;
5138}
5139
5140impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCopyRequest>
5141 for CapabilityStoreDictionaryCopyRequest
5142{
5143 #[inline]
5144 fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCopyRequest) -> Self {
5145 Self {
5146 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
5147
5148 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
5149 }
5150 }
5151}
5152
5153#[derive(Clone, Debug)]
5155#[repr(C)]
5156pub struct WireCapabilityStoreDictionaryCopyRequest {
5157 pub id: ::fidl_next::WireU64,
5158
5159 pub dest_id: ::fidl_next::WireU64,
5160}
5161static_assertions::const_assert_eq!(
5162 std::mem::size_of::<WireCapabilityStoreDictionaryCopyRequest>(),
5163 16
5164);
5165static_assertions::const_assert_eq!(
5166 std::mem::align_of::<WireCapabilityStoreDictionaryCopyRequest>(),
5167 8
5168);
5169
5170static_assertions::const_assert_eq!(
5171 std::mem::offset_of!(WireCapabilityStoreDictionaryCopyRequest, id),
5172 0
5173);
5174
5175static_assertions::const_assert_eq!(
5176 std::mem::offset_of!(WireCapabilityStoreDictionaryCopyRequest, dest_id),
5177 8
5178);
5179
5180unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryCopyRequest {
5181 type Decoded<'de> = WireCapabilityStoreDictionaryCopyRequest;
5182
5183 #[inline]
5184 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5185 ::fidl_next::munge! {
5186 let Self {
5187
5188 id,
5189 dest_id,
5190
5191 } = &mut *out_;
5192 }
5193
5194 ::fidl_next::Wire::zero_padding(id);
5195
5196 ::fidl_next::Wire::zero_padding(dest_id);
5197 }
5198}
5199
5200unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCopyRequest
5201where
5202 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5203{
5204 fn decode(
5205 slot_: ::fidl_next::Slot<'_, Self>,
5206 decoder_: &mut ___D,
5207 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5208 ::fidl_next::munge! {
5209 let Self {
5210
5211 mut id,
5212 mut dest_id,
5213
5214 } = slot_;
5215 }
5216
5217 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5218
5219 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
5220
5221 Ok(())
5222 }
5223}
5224
5225pub type CapabilityStoreDictionaryCopyResponse = ();
5226
5227pub type WireCapabilityStoreDictionaryCopyResponse = ();
5229
5230#[derive(PartialEq, Debug)]
5231pub struct CapabilityStoreDictionaryKeysRequest {
5232 pub id: u64,
5233
5234 pub iterator:
5235 ::fidl_next::ServerEnd<crate::DictionaryKeysIterator, ::fidl_next::fuchsia::zx::Channel>,
5236}
5237
5238impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest {
5239 type Encoded = WireCapabilityStoreDictionaryKeysRequest;
5240}
5241
5242unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest
5243where
5244 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5245 ___E: ::fidl_next::fuchsia::HandleEncoder,
5246{
5247 #[inline]
5248 fn encode(
5249 self,
5250 encoder_: &mut ___E,
5251 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5253 ::fidl_next::munge! {
5254 let Self::Encoded {
5255 id,
5256 iterator,
5257
5258 } = out_;
5259 }
5260
5261 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5262
5263 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5264
5265 Ok(())
5266 }
5267}
5268
5269impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysRequest {
5270 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryKeysRequest>;
5271}
5272
5273unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysRequest
5274where
5275 ___E: ::fidl_next::Encoder + ?Sized,
5276 CapabilityStoreDictionaryKeysRequest: ::fidl_next::Encode<___E>,
5277{
5278 #[inline]
5279 fn encode_option(
5280 this: ::core::option::Option<Self>,
5281 encoder: &mut ___E,
5282 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5283 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5284 if let Some(inner) = this {
5285 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5286 ::fidl_next::WireBox::encode_present(out);
5287 } else {
5288 ::fidl_next::WireBox::encode_absent(out);
5289 }
5290
5291 Ok(())
5292 }
5293}
5294
5295impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryKeysRequest>
5296 for CapabilityStoreDictionaryKeysRequest
5297{
5298 #[inline]
5299 fn from_wire(wire: WireCapabilityStoreDictionaryKeysRequest) -> Self {
5300 Self {
5301 id: ::fidl_next::FromWire::from_wire(wire.id),
5302
5303 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5304 }
5305 }
5306}
5307
5308impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryKeysRequest {
5309 type Natural = CapabilityStoreDictionaryKeysRequest;
5310}
5311
5312#[derive(Debug)]
5314#[repr(C)]
5315pub struct WireCapabilityStoreDictionaryKeysRequest {
5316 pub id: ::fidl_next::WireU64,
5317
5318 pub iterator:
5319 ::fidl_next::ServerEnd<crate::DictionaryKeysIterator, ::fidl_next::fuchsia::WireChannel>,
5320}
5321static_assertions::const_assert_eq!(
5322 std::mem::size_of::<WireCapabilityStoreDictionaryKeysRequest>(),
5323 16
5324);
5325static_assertions::const_assert_eq!(
5326 std::mem::align_of::<WireCapabilityStoreDictionaryKeysRequest>(),
5327 8
5328);
5329
5330static_assertions::const_assert_eq!(
5331 std::mem::offset_of!(WireCapabilityStoreDictionaryKeysRequest, id),
5332 0
5333);
5334
5335static_assertions::const_assert_eq!(
5336 std::mem::offset_of!(WireCapabilityStoreDictionaryKeysRequest, iterator),
5337 8
5338);
5339
5340unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryKeysRequest {
5341 type Decoded<'de> = WireCapabilityStoreDictionaryKeysRequest;
5342
5343 #[inline]
5344 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5345 ::fidl_next::munge! {
5346 let Self {
5347
5348 id,
5349 iterator,
5350
5351 } = &mut *out_;
5352 }
5353
5354 ::fidl_next::Wire::zero_padding(id);
5355
5356 ::fidl_next::Wire::zero_padding(iterator);
5357
5358 unsafe {
5359 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5360 }
5361 }
5362}
5363
5364unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryKeysRequest
5365where
5366 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5367 ___D: ::fidl_next::fuchsia::HandleDecoder,
5368{
5369 fn decode(
5370 slot_: ::fidl_next::Slot<'_, Self>,
5371 decoder_: &mut ___D,
5372 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5373 ::fidl_next::munge! {
5374 let Self {
5375
5376 mut id,
5377 mut iterator,
5378
5379 } = slot_;
5380 }
5381
5382 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5383
5384 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5385
5386 Ok(())
5387 }
5388}
5389
5390pub type CapabilityStoreDictionaryKeysResponse = ();
5391
5392pub type WireCapabilityStoreDictionaryKeysResponse = ();
5394
5395#[derive(PartialEq, Debug)]
5396pub struct CapabilityStoreDictionaryEnumerateRequest {
5397 pub id: u64,
5398
5399 pub iterator: ::fidl_next::ServerEnd<
5400 crate::DictionaryEnumerateIterator,
5401 ::fidl_next::fuchsia::zx::Channel,
5402 >,
5403}
5404
5405impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest {
5406 type Encoded = WireCapabilityStoreDictionaryEnumerateRequest;
5407}
5408
5409unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateRequest
5410where
5411 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5412 ___E: ::fidl_next::fuchsia::HandleEncoder,
5413{
5414 #[inline]
5415 fn encode(
5416 self,
5417 encoder_: &mut ___E,
5418 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5419 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5420 ::fidl_next::munge! {
5421 let Self::Encoded {
5422 id,
5423 iterator,
5424
5425 } = out_;
5426 }
5427
5428 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5429
5430 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5431
5432 Ok(())
5433 }
5434}
5435
5436impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateRequest {
5437 type EncodedOption =
5438 ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryEnumerateRequest>;
5439}
5440
5441unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateRequest
5442where
5443 ___E: ::fidl_next::Encoder + ?Sized,
5444 CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Encode<___E>,
5445{
5446 #[inline]
5447 fn encode_option(
5448 this: ::core::option::Option<Self>,
5449 encoder: &mut ___E,
5450 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5451 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5452 if let Some(inner) = this {
5453 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5454 ::fidl_next::WireBox::encode_present(out);
5455 } else {
5456 ::fidl_next::WireBox::encode_absent(out);
5457 }
5458
5459 Ok(())
5460 }
5461}
5462
5463impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryEnumerateRequest>
5464 for CapabilityStoreDictionaryEnumerateRequest
5465{
5466 #[inline]
5467 fn from_wire(wire: WireCapabilityStoreDictionaryEnumerateRequest) -> Self {
5468 Self {
5469 id: ::fidl_next::FromWire::from_wire(wire.id),
5470
5471 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5472 }
5473 }
5474}
5475
5476impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryEnumerateRequest {
5477 type Natural = CapabilityStoreDictionaryEnumerateRequest;
5478}
5479
5480#[derive(Debug)]
5482#[repr(C)]
5483pub struct WireCapabilityStoreDictionaryEnumerateRequest {
5484 pub id: ::fidl_next::WireU64,
5485
5486 pub iterator: ::fidl_next::ServerEnd<
5487 crate::DictionaryEnumerateIterator,
5488 ::fidl_next::fuchsia::WireChannel,
5489 >,
5490}
5491static_assertions::const_assert_eq!(
5492 std::mem::size_of::<WireCapabilityStoreDictionaryEnumerateRequest>(),
5493 16
5494);
5495static_assertions::const_assert_eq!(
5496 std::mem::align_of::<WireCapabilityStoreDictionaryEnumerateRequest>(),
5497 8
5498);
5499
5500static_assertions::const_assert_eq!(
5501 std::mem::offset_of!(WireCapabilityStoreDictionaryEnumerateRequest, id),
5502 0
5503);
5504
5505static_assertions::const_assert_eq!(
5506 std::mem::offset_of!(WireCapabilityStoreDictionaryEnumerateRequest, iterator),
5507 8
5508);
5509
5510unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryEnumerateRequest {
5511 type Decoded<'de> = WireCapabilityStoreDictionaryEnumerateRequest;
5512
5513 #[inline]
5514 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5515 ::fidl_next::munge! {
5516 let Self {
5517
5518 id,
5519 iterator,
5520
5521 } = &mut *out_;
5522 }
5523
5524 ::fidl_next::Wire::zero_padding(id);
5525
5526 ::fidl_next::Wire::zero_padding(iterator);
5527
5528 unsafe {
5529 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5530 }
5531 }
5532}
5533
5534unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryEnumerateRequest
5535where
5536 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5537 ___D: ::fidl_next::fuchsia::HandleDecoder,
5538{
5539 fn decode(
5540 slot_: ::fidl_next::Slot<'_, Self>,
5541 decoder_: &mut ___D,
5542 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5543 ::fidl_next::munge! {
5544 let Self {
5545
5546 mut id,
5547 mut iterator,
5548
5549 } = slot_;
5550 }
5551
5552 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5553
5554 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5555
5556 Ok(())
5557 }
5558}
5559
5560pub type CapabilityStoreDictionaryEnumerateResponse = ();
5561
5562pub type WireCapabilityStoreDictionaryEnumerateResponse = ();
5564
5565#[derive(PartialEq, Debug)]
5566pub struct CapabilityStoreDictionaryDrainRequest {
5567 pub id: u64,
5568
5569 pub iterator: ::core::option::Option<
5570 ::fidl_next::ServerEnd<crate::DictionaryDrainIterator, ::fidl_next::fuchsia::zx::Channel>,
5571 >,
5572}
5573
5574impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest {
5575 type Encoded = WireCapabilityStoreDictionaryDrainRequest;
5576}
5577
5578unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainRequest
5579where
5580 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5581 ___E: ::fidl_next::fuchsia::HandleEncoder,
5582{
5583 #[inline]
5584 fn encode(
5585 self,
5586 encoder_: &mut ___E,
5587 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5589 ::fidl_next::munge! {
5590 let Self::Encoded {
5591 id,
5592 iterator,
5593
5594 } = out_;
5595 }
5596
5597 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5598
5599 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5600
5601 Ok(())
5602 }
5603}
5604
5605impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainRequest {
5606 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryDrainRequest>;
5607}
5608
5609unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainRequest
5610where
5611 ___E: ::fidl_next::Encoder + ?Sized,
5612 CapabilityStoreDictionaryDrainRequest: ::fidl_next::Encode<___E>,
5613{
5614 #[inline]
5615 fn encode_option(
5616 this: ::core::option::Option<Self>,
5617 encoder: &mut ___E,
5618 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5619 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5620 if let Some(inner) = this {
5621 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5622 ::fidl_next::WireBox::encode_present(out);
5623 } else {
5624 ::fidl_next::WireBox::encode_absent(out);
5625 }
5626
5627 Ok(())
5628 }
5629}
5630
5631impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryDrainRequest>
5632 for CapabilityStoreDictionaryDrainRequest
5633{
5634 #[inline]
5635 fn from_wire(wire: WireCapabilityStoreDictionaryDrainRequest) -> Self {
5636 Self {
5637 id: ::fidl_next::FromWire::from_wire(wire.id),
5638
5639 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5640 }
5641 }
5642}
5643
5644impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryDrainRequest {
5645 type Natural = CapabilityStoreDictionaryDrainRequest;
5646}
5647
5648#[derive(Debug)]
5650#[repr(C)]
5651pub struct WireCapabilityStoreDictionaryDrainRequest {
5652 pub id: ::fidl_next::WireU64,
5653
5654 pub iterator: ::fidl_next::ServerEnd<
5655 crate::DictionaryDrainIterator,
5656 ::fidl_next::fuchsia::WireOptionalChannel,
5657 >,
5658}
5659static_assertions::const_assert_eq!(
5660 std::mem::size_of::<WireCapabilityStoreDictionaryDrainRequest>(),
5661 16
5662);
5663static_assertions::const_assert_eq!(
5664 std::mem::align_of::<WireCapabilityStoreDictionaryDrainRequest>(),
5665 8
5666);
5667
5668static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(WireCapabilityStoreDictionaryDrainRequest, id),
5670 0
5671);
5672
5673static_assertions::const_assert_eq!(
5674 std::mem::offset_of!(WireCapabilityStoreDictionaryDrainRequest, iterator),
5675 8
5676);
5677
5678unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryDrainRequest {
5679 type Decoded<'de> = WireCapabilityStoreDictionaryDrainRequest;
5680
5681 #[inline]
5682 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5683 ::fidl_next::munge! {
5684 let Self {
5685
5686 id,
5687 iterator,
5688
5689 } = &mut *out_;
5690 }
5691
5692 ::fidl_next::Wire::zero_padding(id);
5693
5694 ::fidl_next::Wire::zero_padding(iterator);
5695
5696 unsafe {
5697 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5698 }
5699 }
5700}
5701
5702unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryDrainRequest
5703where
5704 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5705 ___D: ::fidl_next::fuchsia::HandleDecoder,
5706{
5707 fn decode(
5708 slot_: ::fidl_next::Slot<'_, Self>,
5709 decoder_: &mut ___D,
5710 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5711 ::fidl_next::munge! {
5712 let Self {
5713
5714 mut id,
5715 mut iterator,
5716
5717 } = slot_;
5718 }
5719
5720 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5721
5722 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5723
5724 Ok(())
5725 }
5726}
5727
5728pub type CapabilityStoreDictionaryDrainResponse = ();
5729
5730pub type WireCapabilityStoreDictionaryDrainResponse = ();
5732
5733#[derive(PartialEq, Debug)]
5734pub struct CapabilityStoreExportResponse {
5735 pub capability: crate::Capability,
5736}
5737
5738impl ::fidl_next::Encodable for CapabilityStoreExportResponse {
5739 type Encoded = WireCapabilityStoreExportResponse<'static>;
5740}
5741
5742unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse
5743where
5744 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5745 ___E: ::fidl_next::Encoder,
5746 ___E: ::fidl_next::fuchsia::HandleEncoder,
5747{
5748 #[inline]
5749 fn encode(
5750 self,
5751 encoder_: &mut ___E,
5752 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5754 ::fidl_next::munge! {
5755 let Self::Encoded {
5756 capability,
5757
5758 } = out_;
5759 }
5760
5761 ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
5762
5763 Ok(())
5764 }
5765}
5766
5767impl ::fidl_next::EncodableOption for CapabilityStoreExportResponse {
5768 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreExportResponse<'static>>;
5769}
5770
5771unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportResponse
5772where
5773 ___E: ::fidl_next::Encoder + ?Sized,
5774 CapabilityStoreExportResponse: ::fidl_next::Encode<___E>,
5775{
5776 #[inline]
5777 fn encode_option(
5778 this: ::core::option::Option<Self>,
5779 encoder: &mut ___E,
5780 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5781 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5782 if let Some(inner) = this {
5783 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5784 ::fidl_next::WireBox::encode_present(out);
5785 } else {
5786 ::fidl_next::WireBox::encode_absent(out);
5787 }
5788
5789 Ok(())
5790 }
5791}
5792
5793impl<'de> ::fidl_next::FromWire<WireCapabilityStoreExportResponse<'de>>
5794 for CapabilityStoreExportResponse
5795{
5796 #[inline]
5797 fn from_wire(wire: WireCapabilityStoreExportResponse<'de>) -> Self {
5798 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
5799 }
5800}
5801
5802impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreExportResponse<'de> {
5803 type Natural = CapabilityStoreExportResponse;
5804}
5805
5806#[derive(Debug)]
5808#[repr(C)]
5809pub struct WireCapabilityStoreExportResponse<'de> {
5810 pub capability: crate::WireCapability<'de>,
5811}
5812static_assertions::const_assert_eq!(
5813 std::mem::size_of::<WireCapabilityStoreExportResponse<'_>>(),
5814 16
5815);
5816static_assertions::const_assert_eq!(
5817 std::mem::align_of::<WireCapabilityStoreExportResponse<'_>>(),
5818 8
5819);
5820
5821static_assertions::const_assert_eq!(
5822 std::mem::offset_of!(WireCapabilityStoreExportResponse<'_>, capability),
5823 0
5824);
5825
5826unsafe impl ::fidl_next::Wire for WireCapabilityStoreExportResponse<'static> {
5827 type Decoded<'de> = WireCapabilityStoreExportResponse<'de>;
5828
5829 #[inline]
5830 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5831 ::fidl_next::munge! {
5832 let Self {
5833
5834 capability,
5835
5836 } = &mut *out_;
5837 }
5838
5839 ::fidl_next::Wire::zero_padding(capability);
5840 }
5841}
5842
5843unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportResponse<'static>
5844where
5845 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5846 ___D: ::fidl_next::Decoder,
5847 ___D: ::fidl_next::fuchsia::HandleDecoder,
5848{
5849 fn decode(
5850 slot_: ::fidl_next::Slot<'_, Self>,
5851 decoder_: &mut ___D,
5852 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5853 ::fidl_next::munge! {
5854 let Self {
5855
5856 mut capability,
5857
5858 } = slot_;
5859 }
5860
5861 ::fidl_next::Decode::decode(capability.as_mut(), decoder_)?;
5862
5863 Ok(())
5864 }
5865}
5866
5867#[derive(PartialEq, Debug)]
5868pub struct CapabilityStoreImportRequest {
5869 pub id: u64,
5870
5871 pub capability: crate::Capability,
5872}
5873
5874impl ::fidl_next::Encodable for CapabilityStoreImportRequest {
5875 type Encoded = WireCapabilityStoreImportRequest<'static>;
5876}
5877
5878unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest
5879where
5880 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5881 ___E: ::fidl_next::Encoder,
5882 ___E: ::fidl_next::fuchsia::HandleEncoder,
5883{
5884 #[inline]
5885 fn encode(
5886 self,
5887 encoder_: &mut ___E,
5888 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5889 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5890 ::fidl_next::munge! {
5891 let Self::Encoded {
5892 id,
5893 capability,
5894
5895 } = out_;
5896 }
5897
5898 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5899
5900 ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
5901
5902 Ok(())
5903 }
5904}
5905
5906impl ::fidl_next::EncodableOption for CapabilityStoreImportRequest {
5907 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreImportRequest<'static>>;
5908}
5909
5910unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportRequest
5911where
5912 ___E: ::fidl_next::Encoder + ?Sized,
5913 CapabilityStoreImportRequest: ::fidl_next::Encode<___E>,
5914{
5915 #[inline]
5916 fn encode_option(
5917 this: ::core::option::Option<Self>,
5918 encoder: &mut ___E,
5919 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5920 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5921 if let Some(inner) = this {
5922 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5923 ::fidl_next::WireBox::encode_present(out);
5924 } else {
5925 ::fidl_next::WireBox::encode_absent(out);
5926 }
5927
5928 Ok(())
5929 }
5930}
5931
5932impl<'de> ::fidl_next::FromWire<WireCapabilityStoreImportRequest<'de>>
5933 for CapabilityStoreImportRequest
5934{
5935 #[inline]
5936 fn from_wire(wire: WireCapabilityStoreImportRequest<'de>) -> Self {
5937 Self {
5938 id: ::fidl_next::FromWire::from_wire(wire.id),
5939
5940 capability: ::fidl_next::FromWire::from_wire(wire.capability),
5941 }
5942 }
5943}
5944
5945impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreImportRequest<'de> {
5946 type Natural = CapabilityStoreImportRequest;
5947}
5948
5949#[derive(Debug)]
5951#[repr(C)]
5952pub struct WireCapabilityStoreImportRequest<'de> {
5953 pub id: ::fidl_next::WireU64,
5954
5955 pub capability: crate::WireCapability<'de>,
5956}
5957static_assertions::const_assert_eq!(
5958 std::mem::size_of::<WireCapabilityStoreImportRequest<'_>>(),
5959 24
5960);
5961static_assertions::const_assert_eq!(
5962 std::mem::align_of::<WireCapabilityStoreImportRequest<'_>>(),
5963 8
5964);
5965
5966static_assertions::const_assert_eq!(
5967 std::mem::offset_of!(WireCapabilityStoreImportRequest<'_>, id),
5968 0
5969);
5970
5971static_assertions::const_assert_eq!(
5972 std::mem::offset_of!(WireCapabilityStoreImportRequest<'_>, capability),
5973 8
5974);
5975
5976unsafe impl ::fidl_next::Wire for WireCapabilityStoreImportRequest<'static> {
5977 type Decoded<'de> = WireCapabilityStoreImportRequest<'de>;
5978
5979 #[inline]
5980 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5981 ::fidl_next::munge! {
5982 let Self {
5983
5984 id,
5985 capability,
5986
5987 } = &mut *out_;
5988 }
5989
5990 ::fidl_next::Wire::zero_padding(id);
5991
5992 ::fidl_next::Wire::zero_padding(capability);
5993 }
5994}
5995
5996unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreImportRequest<'static>
5997where
5998 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5999 ___D: ::fidl_next::Decoder,
6000 ___D: ::fidl_next::fuchsia::HandleDecoder,
6001{
6002 fn decode(
6003 slot_: ::fidl_next::Slot<'_, Self>,
6004 decoder_: &mut ___D,
6005 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6006 ::fidl_next::munge! {
6007 let Self {
6008
6009 mut id,
6010 mut capability,
6011
6012 } = slot_;
6013 }
6014
6015 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6016
6017 ::fidl_next::Decode::decode(capability.as_mut(), decoder_)?;
6018
6019 Ok(())
6020 }
6021}
6022
6023#[derive(PartialEq, Debug)]
6024pub struct CapabilityStoreDirConnectorCreateRequest {
6025 pub id: u64,
6026
6027 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
6028}
6029
6030impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest {
6031 type Encoded = WireCapabilityStoreDirConnectorCreateRequest;
6032}
6033
6034unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateRequest
6035where
6036 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6037 ___E: ::fidl_next::fuchsia::HandleEncoder,
6038{
6039 #[inline]
6040 fn encode(
6041 self,
6042 encoder_: &mut ___E,
6043 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6044 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6045 ::fidl_next::munge! {
6046 let Self::Encoded {
6047 id,
6048 receiver,
6049
6050 } = out_;
6051 }
6052
6053 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6054
6055 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
6056
6057 Ok(())
6058 }
6059}
6060
6061impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateRequest {
6062 type EncodedOption =
6063 ::fidl_next::WireBox<'static, WireCapabilityStoreDirConnectorCreateRequest>;
6064}
6065
6066unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateRequest
6067where
6068 ___E: ::fidl_next::Encoder + ?Sized,
6069 CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Encode<___E>,
6070{
6071 #[inline]
6072 fn encode_option(
6073 this: ::core::option::Option<Self>,
6074 encoder: &mut ___E,
6075 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6076 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6077 if let Some(inner) = this {
6078 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6079 ::fidl_next::WireBox::encode_present(out);
6080 } else {
6081 ::fidl_next::WireBox::encode_absent(out);
6082 }
6083
6084 Ok(())
6085 }
6086}
6087
6088impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorCreateRequest>
6089 for CapabilityStoreDirConnectorCreateRequest
6090{
6091 #[inline]
6092 fn from_wire(wire: WireCapabilityStoreDirConnectorCreateRequest) -> Self {
6093 Self {
6094 id: ::fidl_next::FromWire::from_wire(wire.id),
6095
6096 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
6097 }
6098 }
6099}
6100
6101impl ::fidl_next::IntoNatural for WireCapabilityStoreDirConnectorCreateRequest {
6102 type Natural = CapabilityStoreDirConnectorCreateRequest;
6103}
6104
6105#[derive(Debug)]
6107#[repr(C)]
6108pub struct WireCapabilityStoreDirConnectorCreateRequest {
6109 pub id: ::fidl_next::WireU64,
6110
6111 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
6112}
6113static_assertions::const_assert_eq!(
6114 std::mem::size_of::<WireCapabilityStoreDirConnectorCreateRequest>(),
6115 16
6116);
6117static_assertions::const_assert_eq!(
6118 std::mem::align_of::<WireCapabilityStoreDirConnectorCreateRequest>(),
6119 8
6120);
6121
6122static_assertions::const_assert_eq!(
6123 std::mem::offset_of!(WireCapabilityStoreDirConnectorCreateRequest, id),
6124 0
6125);
6126
6127static_assertions::const_assert_eq!(
6128 std::mem::offset_of!(WireCapabilityStoreDirConnectorCreateRequest, receiver),
6129 8
6130);
6131
6132unsafe impl ::fidl_next::Wire for WireCapabilityStoreDirConnectorCreateRequest {
6133 type Decoded<'de> = WireCapabilityStoreDirConnectorCreateRequest;
6134
6135 #[inline]
6136 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6137 ::fidl_next::munge! {
6138 let Self {
6139
6140 id,
6141 receiver,
6142
6143 } = &mut *out_;
6144 }
6145
6146 ::fidl_next::Wire::zero_padding(id);
6147
6148 ::fidl_next::Wire::zero_padding(receiver);
6149
6150 unsafe {
6151 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
6152 }
6153 }
6154}
6155
6156unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorCreateRequest
6157where
6158 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6159 ___D: ::fidl_next::fuchsia::HandleDecoder,
6160{
6161 fn decode(
6162 slot_: ::fidl_next::Slot<'_, Self>,
6163 decoder_: &mut ___D,
6164 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6165 ::fidl_next::munge! {
6166 let Self {
6167
6168 mut id,
6169 mut receiver,
6170
6171 } = slot_;
6172 }
6173
6174 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6175
6176 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_)?;
6177
6178 Ok(())
6179 }
6180}
6181
6182#[derive(PartialEq, Debug)]
6183pub struct CapabilityStoreDirConnectorOpenRequest {
6184 pub id: u64,
6185
6186 pub server_end: ::fidl_next::ServerEnd<
6187 ::fidl_next_fuchsia_io::Directory,
6188 ::fidl_next::fuchsia::zx::Channel,
6189 >,
6190}
6191
6192impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest {
6193 type Encoded = WireCapabilityStoreDirConnectorOpenRequest;
6194}
6195
6196unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenRequest
6197where
6198 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6199 ___E: ::fidl_next::fuchsia::HandleEncoder,
6200{
6201 #[inline]
6202 fn encode(
6203 self,
6204 encoder_: &mut ___E,
6205 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6207 ::fidl_next::munge! {
6208 let Self::Encoded {
6209 id,
6210 server_end,
6211
6212 } = out_;
6213 }
6214
6215 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6216
6217 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
6218
6219 Ok(())
6220 }
6221}
6222
6223impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenRequest {
6224 type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDirConnectorOpenRequest>;
6225}
6226
6227unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenRequest
6228where
6229 ___E: ::fidl_next::Encoder + ?Sized,
6230 CapabilityStoreDirConnectorOpenRequest: ::fidl_next::Encode<___E>,
6231{
6232 #[inline]
6233 fn encode_option(
6234 this: ::core::option::Option<Self>,
6235 encoder: &mut ___E,
6236 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6238 if let Some(inner) = this {
6239 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6240 ::fidl_next::WireBox::encode_present(out);
6241 } else {
6242 ::fidl_next::WireBox::encode_absent(out);
6243 }
6244
6245 Ok(())
6246 }
6247}
6248
6249impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorOpenRequest>
6250 for CapabilityStoreDirConnectorOpenRequest
6251{
6252 #[inline]
6253 fn from_wire(wire: WireCapabilityStoreDirConnectorOpenRequest) -> Self {
6254 Self {
6255 id: ::fidl_next::FromWire::from_wire(wire.id),
6256
6257 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
6258 }
6259 }
6260}
6261
6262impl ::fidl_next::IntoNatural for WireCapabilityStoreDirConnectorOpenRequest {
6263 type Natural = CapabilityStoreDirConnectorOpenRequest;
6264}
6265
6266#[derive(Debug)]
6268#[repr(C)]
6269pub struct WireCapabilityStoreDirConnectorOpenRequest {
6270 pub id: ::fidl_next::WireU64,
6271
6272 pub server_end: ::fidl_next::ServerEnd<
6273 ::fidl_next_fuchsia_io::Directory,
6274 ::fidl_next::fuchsia::WireChannel,
6275 >,
6276}
6277static_assertions::const_assert_eq!(
6278 std::mem::size_of::<WireCapabilityStoreDirConnectorOpenRequest>(),
6279 16
6280);
6281static_assertions::const_assert_eq!(
6282 std::mem::align_of::<WireCapabilityStoreDirConnectorOpenRequest>(),
6283 8
6284);
6285
6286static_assertions::const_assert_eq!(
6287 std::mem::offset_of!(WireCapabilityStoreDirConnectorOpenRequest, id),
6288 0
6289);
6290
6291static_assertions::const_assert_eq!(
6292 std::mem::offset_of!(WireCapabilityStoreDirConnectorOpenRequest, server_end),
6293 8
6294);
6295
6296unsafe impl ::fidl_next::Wire for WireCapabilityStoreDirConnectorOpenRequest {
6297 type Decoded<'de> = WireCapabilityStoreDirConnectorOpenRequest;
6298
6299 #[inline]
6300 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6301 ::fidl_next::munge! {
6302 let Self {
6303
6304 id,
6305 server_end,
6306
6307 } = &mut *out_;
6308 }
6309
6310 ::fidl_next::Wire::zero_padding(id);
6311
6312 ::fidl_next::Wire::zero_padding(server_end);
6313
6314 unsafe {
6315 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
6316 }
6317 }
6318}
6319
6320unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorOpenRequest
6321where
6322 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6323 ___D: ::fidl_next::fuchsia::HandleDecoder,
6324{
6325 fn decode(
6326 slot_: ::fidl_next::Slot<'_, Self>,
6327 decoder_: &mut ___D,
6328 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6329 ::fidl_next::munge! {
6330 let Self {
6331
6332 mut id,
6333 mut server_end,
6334
6335 } = slot_;
6336 }
6337
6338 ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6339
6340 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
6341
6342 Ok(())
6343 }
6344}
6345
6346#[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"]
6348#[derive(PartialEq, Debug)]
6349pub struct CapabilityStore;
6350
6351impl ::fidl_next::Discoverable for CapabilityStore {
6352 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
6353}
6354
6355pub mod capability_store {
6356 pub mod prelude {
6357 pub use crate::{
6358 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
6359 capability_store,
6360 };
6361
6362 pub use crate::CapabilityStoreConnectorCreateRequest;
6363
6364 pub use crate::CapabilityStoreConnectorOpenRequest;
6365
6366 pub use crate::CapabilityStoreDictionaryCopyRequest;
6367
6368 pub use crate::CapabilityStoreDictionaryCreateRequest;
6369
6370 pub use crate::CapabilityStoreDictionaryDrainRequest;
6371
6372 pub use crate::CapabilityStoreDictionaryEnumerateRequest;
6373
6374 pub use crate::CapabilityStoreDictionaryGetRequest;
6375
6376 pub use crate::CapabilityStoreDictionaryInsertRequest;
6377
6378 pub use crate::CapabilityStoreDictionaryKeysRequest;
6379
6380 pub use crate::CapabilityStoreDictionaryLegacyExportRequest;
6381
6382 pub use crate::CapabilityStoreDictionaryLegacyImportRequest;
6383
6384 pub use crate::CapabilityStoreDictionaryRemoveRequest;
6385
6386 pub use crate::CapabilityStoreDirConnectorCreateRequest;
6387
6388 pub use crate::CapabilityStoreDirConnectorOpenRequest;
6389
6390 pub use crate::CapabilityStoreDropRequest;
6391
6392 pub use crate::CapabilityStoreDuplicateRequest;
6393
6394 pub use crate::CapabilityStoreError;
6395
6396 pub use crate::CapabilityStoreExportRequest;
6397
6398 pub use crate::CapabilityStoreImportRequest;
6399
6400 pub use crate::CapabilityStoreConnectorCreateResponse;
6401
6402 pub use crate::CapabilityStoreConnectorOpenResponse;
6403
6404 pub use crate::CapabilityStoreDictionaryCopyResponse;
6405
6406 pub use crate::CapabilityStoreDictionaryCreateResponse;
6407
6408 pub use crate::CapabilityStoreDictionaryDrainResponse;
6409
6410 pub use crate::CapabilityStoreDictionaryEnumerateResponse;
6411
6412 pub use crate::CapabilityStoreDictionaryGetResponse;
6413
6414 pub use crate::CapabilityStoreDictionaryInsertResponse;
6415
6416 pub use crate::CapabilityStoreDictionaryKeysResponse;
6417
6418 pub use crate::CapabilityStoreDictionaryLegacyExportResponse;
6419
6420 pub use crate::CapabilityStoreDictionaryLegacyImportResponse;
6421
6422 pub use crate::CapabilityStoreDictionaryRemoveResponse;
6423
6424 pub use crate::CapabilityStoreDirConnectorCreateResponse;
6425
6426 pub use crate::CapabilityStoreDirConnectorOpenResponse;
6427
6428 pub use crate::CapabilityStoreDropResponse;
6429
6430 pub use crate::CapabilityStoreDuplicateResponse;
6431
6432 pub use crate::CapabilityStoreExportResponse;
6433
6434 pub use crate::CapabilityStoreImportResponse;
6435 }
6436
6437 pub struct Duplicate;
6438
6439 impl ::fidl_next::Method for Duplicate {
6440 const ORDINAL: u64 = 6727592627741008260;
6441
6442 type Protocol = crate::CapabilityStore;
6443
6444 type Request = crate::WireCapabilityStoreDuplicateRequest;
6445
6446 type Response = ::fidl_next::WireFlexibleResult<
6447 'static,
6448 crate::WireCapabilityStoreDuplicateResponse,
6449 crate::WireCapabilityStoreError,
6450 >;
6451 }
6452
6453 pub struct Drop;
6454
6455 impl ::fidl_next::Method for Drop {
6456 const ORDINAL: u64 = 753328233834620249;
6457
6458 type Protocol = crate::CapabilityStore;
6459
6460 type Request = crate::WireCapabilityStoreDropRequest;
6461
6462 type Response = ::fidl_next::WireFlexibleResult<
6463 'static,
6464 crate::WireCapabilityStoreDropResponse,
6465 crate::WireCapabilityStoreError,
6466 >;
6467 }
6468
6469 pub struct Export;
6470
6471 impl ::fidl_next::Method for Export {
6472 const ORDINAL: u64 = 226159162093533951;
6473
6474 type Protocol = crate::CapabilityStore;
6475
6476 type Request = crate::WireCapabilityStoreExportRequest;
6477
6478 type Response = ::fidl_next::WireFlexibleResult<
6479 'static,
6480 crate::WireCapabilityStoreExportResponse<'static>,
6481 crate::WireCapabilityStoreError,
6482 >;
6483 }
6484
6485 pub struct Import;
6486
6487 impl ::fidl_next::Method for Import {
6488 const ORDINAL: u64 = 2276030276116435867;
6489
6490 type Protocol = crate::CapabilityStore;
6491
6492 type Request = crate::WireCapabilityStoreImportRequest<'static>;
6493
6494 type Response = ::fidl_next::WireFlexibleResult<
6495 'static,
6496 crate::WireCapabilityStoreImportResponse,
6497 crate::WireCapabilityStoreError,
6498 >;
6499 }
6500
6501 pub struct ConnectorCreate;
6502
6503 impl ::fidl_next::Method for ConnectorCreate {
6504 const ORDINAL: u64 = 2979461408102095909;
6505
6506 type Protocol = crate::CapabilityStore;
6507
6508 type Request = crate::WireCapabilityStoreConnectorCreateRequest;
6509
6510 type Response = ::fidl_next::WireFlexibleResult<
6511 'static,
6512 crate::WireCapabilityStoreConnectorCreateResponse,
6513 crate::WireCapabilityStoreError,
6514 >;
6515 }
6516
6517 pub struct ConnectorOpen;
6518
6519 impl ::fidl_next::Method for ConnectorOpen {
6520 const ORDINAL: u64 = 6016362336453278623;
6521
6522 type Protocol = crate::CapabilityStore;
6523
6524 type Request = crate::WireCapabilityStoreConnectorOpenRequest;
6525
6526 type Response = ::fidl_next::WireFlexibleResult<
6527 'static,
6528 crate::WireCapabilityStoreConnectorOpenResponse,
6529 crate::WireCapabilityStoreError,
6530 >;
6531 }
6532
6533 pub struct DirConnectorCreate;
6534
6535 impl ::fidl_next::Method for DirConnectorCreate {
6536 const ORDINAL: u64 = 1756747594275428795;
6537
6538 type Protocol = crate::CapabilityStore;
6539
6540 type Request = crate::WireCapabilityStoreDirConnectorCreateRequest;
6541
6542 type Response = ::fidl_next::WireFlexibleResult<
6543 'static,
6544 crate::WireCapabilityStoreDirConnectorCreateResponse,
6545 crate::WireCapabilityStoreError,
6546 >;
6547 }
6548
6549 pub struct DirConnectorOpen;
6550
6551 impl ::fidl_next::Method for DirConnectorOpen {
6552 const ORDINAL: u64 = 6219704004220369153;
6553
6554 type Protocol = crate::CapabilityStore;
6555
6556 type Request = crate::WireCapabilityStoreDirConnectorOpenRequest;
6557
6558 type Response = ::fidl_next::WireFlexibleResult<
6559 'static,
6560 crate::WireCapabilityStoreDirConnectorOpenResponse,
6561 crate::WireCapabilityStoreError,
6562 >;
6563 }
6564
6565 pub struct DictionaryCreate;
6566
6567 impl ::fidl_next::Method for DictionaryCreate {
6568 const ORDINAL: u64 = 7608770958894948499;
6569
6570 type Protocol = crate::CapabilityStore;
6571
6572 type Request = crate::WireCapabilityStoreDictionaryCreateRequest;
6573
6574 type Response = ::fidl_next::WireFlexibleResult<
6575 'static,
6576 crate::WireCapabilityStoreDictionaryCreateResponse,
6577 crate::WireCapabilityStoreError,
6578 >;
6579 }
6580
6581 pub struct DictionaryLegacyImport;
6582
6583 impl ::fidl_next::Method for DictionaryLegacyImport {
6584 const ORDINAL: u64 = 8285893703432012383;
6585
6586 type Protocol = crate::CapabilityStore;
6587
6588 type Request = crate::WireCapabilityStoreDictionaryLegacyImportRequest;
6589
6590 type Response = ::fidl_next::WireFlexibleResult<
6591 'static,
6592 crate::WireCapabilityStoreDictionaryLegacyImportResponse,
6593 crate::WireCapabilityStoreError,
6594 >;
6595 }
6596
6597 pub struct DictionaryLegacyExport;
6598
6599 impl ::fidl_next::Method for DictionaryLegacyExport {
6600 const ORDINAL: u64 = 4647175832683306445;
6601
6602 type Protocol = crate::CapabilityStore;
6603
6604 type Request = crate::WireCapabilityStoreDictionaryLegacyExportRequest;
6605
6606 type Response = ::fidl_next::WireFlexibleResult<
6607 'static,
6608 crate::WireCapabilityStoreDictionaryLegacyExportResponse,
6609 crate::WireCapabilityStoreError,
6610 >;
6611 }
6612
6613 pub struct DictionaryInsert;
6614
6615 impl ::fidl_next::Method for DictionaryInsert {
6616 const ORDINAL: u64 = 8575443262986538023;
6617
6618 type Protocol = crate::CapabilityStore;
6619
6620 type Request = crate::WireCapabilityStoreDictionaryInsertRequest<'static>;
6621
6622 type Response = ::fidl_next::WireFlexibleResult<
6623 'static,
6624 crate::WireCapabilityStoreDictionaryInsertResponse,
6625 crate::WireCapabilityStoreError,
6626 >;
6627 }
6628
6629 pub struct DictionaryGet;
6630
6631 impl ::fidl_next::Method for DictionaryGet {
6632 const ORDINAL: u64 = 5592951026866236882;
6633
6634 type Protocol = crate::CapabilityStore;
6635
6636 type Request = crate::WireCapabilityStoreDictionaryGetRequest<'static>;
6637
6638 type Response = ::fidl_next::WireFlexibleResult<
6639 'static,
6640 crate::WireCapabilityStoreDictionaryGetResponse,
6641 crate::WireCapabilityStoreError,
6642 >;
6643 }
6644
6645 pub struct DictionaryRemove;
6646
6647 impl ::fidl_next::Method for DictionaryRemove {
6648 const ORDINAL: u64 = 343892214579320051;
6649
6650 type Protocol = crate::CapabilityStore;
6651
6652 type Request = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>;
6653
6654 type Response = ::fidl_next::WireFlexibleResult<
6655 'static,
6656 crate::WireCapabilityStoreDictionaryRemoveResponse,
6657 crate::WireCapabilityStoreError,
6658 >;
6659 }
6660
6661 pub struct DictionaryCopy;
6662
6663 impl ::fidl_next::Method for DictionaryCopy {
6664 const ORDINAL: u64 = 3977783339739362383;
6665
6666 type Protocol = crate::CapabilityStore;
6667
6668 type Request = crate::WireCapabilityStoreDictionaryCopyRequest;
6669
6670 type Response = ::fidl_next::WireFlexibleResult<
6671 'static,
6672 crate::WireCapabilityStoreDictionaryCopyResponse,
6673 crate::WireCapabilityStoreError,
6674 >;
6675 }
6676
6677 pub struct DictionaryKeys;
6678
6679 impl ::fidl_next::Method for DictionaryKeys {
6680 const ORDINAL: u64 = 597577248872787102;
6681
6682 type Protocol = crate::CapabilityStore;
6683
6684 type Request = crate::WireCapabilityStoreDictionaryKeysRequest;
6685
6686 type Response = ::fidl_next::WireFlexibleResult<
6687 'static,
6688 crate::WireCapabilityStoreDictionaryKeysResponse,
6689 crate::WireCapabilityStoreError,
6690 >;
6691 }
6692
6693 pub struct DictionaryEnumerate;
6694
6695 impl ::fidl_next::Method for DictionaryEnumerate {
6696 const ORDINAL: u64 = 964467096271472193;
6697
6698 type Protocol = crate::CapabilityStore;
6699
6700 type Request = crate::WireCapabilityStoreDictionaryEnumerateRequest;
6701
6702 type Response = ::fidl_next::WireFlexibleResult<
6703 'static,
6704 crate::WireCapabilityStoreDictionaryEnumerateResponse,
6705 crate::WireCapabilityStoreError,
6706 >;
6707 }
6708
6709 pub struct DictionaryDrain;
6710
6711 impl ::fidl_next::Method for DictionaryDrain {
6712 const ORDINAL: u64 = 2928364469569621208;
6713
6714 type Protocol = crate::CapabilityStore;
6715
6716 type Request = crate::WireCapabilityStoreDictionaryDrainRequest;
6717
6718 type Response = ::fidl_next::WireFlexibleResult<
6719 'static,
6720 crate::WireCapabilityStoreDictionaryDrainResponse,
6721 crate::WireCapabilityStoreError,
6722 >;
6723 }
6724
6725 mod ___detail {
6726
6727 pub struct Duplicate<T0, T1> {
6728 id: T0,
6729
6730 dest_id: T1,
6731 }
6732
6733 impl<T0, T1> ::fidl_next::Encodable for Duplicate<T0, T1>
6734 where
6735 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6736 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6737 {
6738 type Encoded = crate::WireCapabilityStoreDuplicateRequest;
6739 }
6740
6741 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Duplicate<T0, T1>
6742 where
6743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6744 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6745 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6746 {
6747 #[inline]
6748 fn encode(
6749 self,
6750 encoder_: &mut ___E,
6751 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6752 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6753 ::fidl_next::munge! {
6754 let Self::Encoded {
6755 id,
6756 dest_id,
6757
6758 } = out_;
6759 }
6760
6761 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6762
6763 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
6764
6765 Ok(())
6766 }
6767 }
6768
6769 pub struct Drop<T0> {
6770 id: T0,
6771 }
6772
6773 impl<T0> ::fidl_next::Encodable for Drop<T0>
6774 where
6775 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6776 {
6777 type Encoded = crate::WireCapabilityStoreDropRequest;
6778 }
6779
6780 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Drop<T0>
6781 where
6782 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6783 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6784 {
6785 #[inline]
6786 fn encode(
6787 self,
6788 encoder_: &mut ___E,
6789 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6790 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6791 ::fidl_next::munge! {
6792 let Self::Encoded {
6793 id,
6794
6795 } = out_;
6796 }
6797
6798 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6799
6800 Ok(())
6801 }
6802 }
6803
6804 pub struct Export<T0> {
6805 id: T0,
6806 }
6807
6808 impl<T0> ::fidl_next::Encodable for Export<T0>
6809 where
6810 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6811 {
6812 type Encoded = crate::WireCapabilityStoreExportRequest;
6813 }
6814
6815 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Export<T0>
6816 where
6817 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6818 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6819 {
6820 #[inline]
6821 fn encode(
6822 self,
6823 encoder_: &mut ___E,
6824 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6825 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6826 ::fidl_next::munge! {
6827 let Self::Encoded {
6828 id,
6829
6830 } = out_;
6831 }
6832
6833 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6834
6835 Ok(())
6836 }
6837 }
6838
6839 pub struct Import<T0, T1> {
6840 id: T0,
6841
6842 capability: T1,
6843 }
6844
6845 impl<T0, T1> ::fidl_next::Encodable for Import<T0, T1>
6846 where
6847 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6848 T1: ::fidl_next::Encodable<Encoded = crate::WireCapability<'static>>,
6849 {
6850 type Encoded = crate::WireCapabilityStoreImportRequest<'static>;
6851 }
6852
6853 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Import<T0, T1>
6854 where
6855 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6856 ___E: ::fidl_next::Encoder,
6857 ___E: ::fidl_next::fuchsia::HandleEncoder,
6858 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6859 T1: ::fidl_next::Encode<___E, Encoded = crate::WireCapability<'static>>,
6860 {
6861 #[inline]
6862 fn encode(
6863 self,
6864 encoder_: &mut ___E,
6865 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6867 ::fidl_next::munge! {
6868 let Self::Encoded {
6869 id,
6870 capability,
6871
6872 } = out_;
6873 }
6874
6875 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6876
6877 ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
6878
6879 Ok(())
6880 }
6881 }
6882
6883 pub struct ConnectorCreate<T0, T1> {
6884 id: T0,
6885
6886 receiver: T1,
6887 }
6888
6889 impl<T0, T1> ::fidl_next::Encodable for ConnectorCreate<T0, T1>
6890 where
6891 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6892 T1: ::fidl_next::Encodable<
6893 Encoded = ::fidl_next::ClientEnd<
6894 crate::Receiver,
6895 ::fidl_next::fuchsia::WireChannel,
6896 >,
6897 >,
6898 {
6899 type Encoded = crate::WireCapabilityStoreConnectorCreateRequest;
6900 }
6901
6902 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for ConnectorCreate<T0, T1>
6903 where
6904 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6905 ___E: ::fidl_next::fuchsia::HandleEncoder,
6906 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6907 T1: ::fidl_next::Encode<
6908 ___E,
6909 Encoded = ::fidl_next::ClientEnd<
6910 crate::Receiver,
6911 ::fidl_next::fuchsia::WireChannel,
6912 >,
6913 >,
6914 {
6915 #[inline]
6916 fn encode(
6917 self,
6918 encoder_: &mut ___E,
6919 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6920 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6921 ::fidl_next::munge! {
6922 let Self::Encoded {
6923 id,
6924 receiver,
6925
6926 } = out_;
6927 }
6928
6929 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6930
6931 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
6932
6933 Ok(())
6934 }
6935 }
6936
6937 pub struct ConnectorOpen<T0, T1> {
6938 id: T0,
6939
6940 server_end: T1,
6941 }
6942
6943 impl<T0, T1> ::fidl_next::Encodable for ConnectorOpen<T0, T1>
6944 where
6945 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6946 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
6947 {
6948 type Encoded = crate::WireCapabilityStoreConnectorOpenRequest;
6949 }
6950
6951 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for ConnectorOpen<T0, T1>
6952 where
6953 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6954 ___E: ::fidl_next::fuchsia::HandleEncoder,
6955 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6956 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
6957 {
6958 #[inline]
6959 fn encode(
6960 self,
6961 encoder_: &mut ___E,
6962 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6963 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6964 ::fidl_next::munge! {
6965 let Self::Encoded {
6966 id,
6967 server_end,
6968
6969 } = out_;
6970 }
6971
6972 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6973
6974 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
6975
6976 Ok(())
6977 }
6978 }
6979
6980 pub struct DirConnectorCreate<T0, T1> {
6981 id: T0,
6982
6983 receiver: T1,
6984 }
6985
6986 impl<T0, T1> ::fidl_next::Encodable for DirConnectorCreate<T0, T1>
6987 where
6988 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6989 T1: ::fidl_next::Encodable<
6990 Encoded = ::fidl_next::ClientEnd<
6991 crate::DirReceiver,
6992 ::fidl_next::fuchsia::WireChannel,
6993 >,
6994 >,
6995 {
6996 type Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest;
6997 }
6998
6999 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DirConnectorCreate<T0, T1>
7000 where
7001 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7002 ___E: ::fidl_next::fuchsia::HandleEncoder,
7003 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7004 T1: ::fidl_next::Encode<
7005 ___E,
7006 Encoded = ::fidl_next::ClientEnd<
7007 crate::DirReceiver,
7008 ::fidl_next::fuchsia::WireChannel,
7009 >,
7010 >,
7011 {
7012 #[inline]
7013 fn encode(
7014 self,
7015 encoder_: &mut ___E,
7016 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7017 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7018 ::fidl_next::munge! {
7019 let Self::Encoded {
7020 id,
7021 receiver,
7022
7023 } = out_;
7024 }
7025
7026 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7027
7028 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
7029
7030 Ok(())
7031 }
7032 }
7033
7034 pub struct DirConnectorOpen<T0, T1> {
7035 id: T0,
7036
7037 server_end: T1,
7038 }
7039
7040 impl<T0, T1> ::fidl_next::Encodable for DirConnectorOpen<T0, T1>
7041 where
7042 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7043 T1: ::fidl_next::Encodable<
7044 Encoded = ::fidl_next::ServerEnd<
7045 ::fidl_next_fuchsia_io::Directory,
7046 ::fidl_next::fuchsia::WireChannel,
7047 >,
7048 >,
7049 {
7050 type Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest;
7051 }
7052
7053 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DirConnectorOpen<T0, T1>
7054 where
7055 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7056 ___E: ::fidl_next::fuchsia::HandleEncoder,
7057 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7058 T1: ::fidl_next::Encode<
7059 ___E,
7060 Encoded = ::fidl_next::ServerEnd<
7061 ::fidl_next_fuchsia_io::Directory,
7062 ::fidl_next::fuchsia::WireChannel,
7063 >,
7064 >,
7065 {
7066 #[inline]
7067 fn encode(
7068 self,
7069 encoder_: &mut ___E,
7070 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7071 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7072 ::fidl_next::munge! {
7073 let Self::Encoded {
7074 id,
7075 server_end,
7076
7077 } = out_;
7078 }
7079
7080 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7081
7082 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
7083
7084 Ok(())
7085 }
7086 }
7087
7088 pub struct DictionaryCreate<T0> {
7089 id: T0,
7090 }
7091
7092 impl<T0> ::fidl_next::Encodable for DictionaryCreate<T0>
7093 where
7094 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7095 {
7096 type Encoded = crate::WireCapabilityStoreDictionaryCreateRequest;
7097 }
7098
7099 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryCreate<T0>
7100 where
7101 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7102 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7103 {
7104 #[inline]
7105 fn encode(
7106 self,
7107 encoder_: &mut ___E,
7108 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7110 ::fidl_next::munge! {
7111 let Self::Encoded {
7112 id,
7113
7114 } = out_;
7115 }
7116
7117 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7118
7119 Ok(())
7120 }
7121 }
7122
7123 pub struct DictionaryLegacyImport<T0, T1> {
7124 id: T0,
7125
7126 client_end: T1,
7127 }
7128
7129 impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyImport<T0, T1>
7130 where
7131 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7132 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
7133 {
7134 type Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest;
7135 }
7136
7137 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryLegacyImport<T0, T1>
7138 where
7139 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7140 ___E: ::fidl_next::fuchsia::HandleEncoder,
7141 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7142 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
7143 {
7144 #[inline]
7145 fn encode(
7146 self,
7147 encoder_: &mut ___E,
7148 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7149 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7150 ::fidl_next::munge! {
7151 let Self::Encoded {
7152 id,
7153 client_end,
7154
7155 } = out_;
7156 }
7157
7158 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7159
7160 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end)?;
7161
7162 Ok(())
7163 }
7164 }
7165
7166 pub struct DictionaryLegacyExport<T0, T1> {
7167 id: T0,
7168
7169 server_end: T1,
7170 }
7171
7172 impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyExport<T0, T1>
7173 where
7174 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7175 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
7176 {
7177 type Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest;
7178 }
7179
7180 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryLegacyExport<T0, T1>
7181 where
7182 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7183 ___E: ::fidl_next::fuchsia::HandleEncoder,
7184 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7185 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
7186 {
7187 #[inline]
7188 fn encode(
7189 self,
7190 encoder_: &mut ___E,
7191 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7192 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7193 ::fidl_next::munge! {
7194 let Self::Encoded {
7195 id,
7196 server_end,
7197
7198 } = out_;
7199 }
7200
7201 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7202
7203 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
7204
7205 Ok(())
7206 }
7207 }
7208
7209 pub struct DictionaryInsert<T0, T1> {
7210 id: T0,
7211
7212 item: T1,
7213 }
7214
7215 impl<T0, T1> ::fidl_next::Encodable for DictionaryInsert<T0, T1>
7216 where
7217 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7218 T1: ::fidl_next::Encodable<Encoded = crate::WireDictionaryItem<'static>>,
7219 {
7220 type Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>;
7221 }
7222
7223 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryInsert<T0, T1>
7224 where
7225 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7226 ___E: ::fidl_next::Encoder,
7227 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7228 T1: ::fidl_next::Encode<___E, Encoded = crate::WireDictionaryItem<'static>>,
7229 {
7230 #[inline]
7231 fn encode(
7232 self,
7233 encoder_: &mut ___E,
7234 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7235 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7236 ::fidl_next::munge! {
7237 let Self::Encoded {
7238 id,
7239 item,
7240
7241 } = out_;
7242 }
7243
7244 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7245
7246 ::fidl_next::Encode::encode(self.item, encoder_, item)?;
7247
7248 Ok(())
7249 }
7250 }
7251
7252 pub struct DictionaryGet<T0, T1, T2> {
7253 id: T0,
7254
7255 key: T1,
7256
7257 dest_id: T2,
7258 }
7259
7260 impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryGet<T0, T1, T2>
7261 where
7262 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7263 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
7264 T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7265 {
7266 type Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>;
7267 }
7268
7269 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for DictionaryGet<T0, T1, T2>
7270 where
7271 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7272 ___E: ::fidl_next::Encoder,
7273 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7274 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
7275 T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7276 {
7277 #[inline]
7278 fn encode(
7279 self,
7280 encoder_: &mut ___E,
7281 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7282 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7283 ::fidl_next::munge! {
7284 let Self::Encoded {
7285 id,
7286 key,
7287 dest_id,
7288
7289 } = out_;
7290 }
7291
7292 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7293
7294 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
7295
7296 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7297
7298 Ok(())
7299 }
7300 }
7301
7302 pub struct DictionaryRemove<T0, T1, T2> {
7303 id: T0,
7304
7305 key: T1,
7306
7307 dest_id: T2,
7308 }
7309
7310 impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryRemove<T0, T1, T2>
7311 where
7312 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7313 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
7314 T2: ::fidl_next::Encodable<
7315 Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
7316 >,
7317 {
7318 type Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>;
7319 }
7320
7321 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for DictionaryRemove<T0, T1, T2>
7322 where
7323 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7324 ___E: ::fidl_next::Encoder,
7325 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7326 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
7327 T2: ::fidl_next::Encode<
7328 ___E,
7329 Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
7330 >,
7331 {
7332 #[inline]
7333 fn encode(
7334 self,
7335 encoder_: &mut ___E,
7336 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7337 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7338 ::fidl_next::munge! {
7339 let Self::Encoded {
7340 id,
7341 key,
7342 dest_id,
7343
7344 } = out_;
7345 }
7346
7347 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7348
7349 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
7350
7351 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7352
7353 Ok(())
7354 }
7355 }
7356
7357 pub struct DictionaryCopy<T0, T1> {
7358 id: T0,
7359
7360 dest_id: T1,
7361 }
7362
7363 impl<T0, T1> ::fidl_next::Encodable for DictionaryCopy<T0, T1>
7364 where
7365 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7366 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7367 {
7368 type Encoded = crate::WireCapabilityStoreDictionaryCopyRequest;
7369 }
7370
7371 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryCopy<T0, T1>
7372 where
7373 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7374 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7375 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7376 {
7377 #[inline]
7378 fn encode(
7379 self,
7380 encoder_: &mut ___E,
7381 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7382 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7383 ::fidl_next::munge! {
7384 let Self::Encoded {
7385 id,
7386 dest_id,
7387
7388 } = out_;
7389 }
7390
7391 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7392
7393 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7394
7395 Ok(())
7396 }
7397 }
7398
7399 pub struct DictionaryKeys<T0, T1> {
7400 id: T0,
7401
7402 iterator: T1,
7403 }
7404
7405 impl<T0, T1> ::fidl_next::Encodable for DictionaryKeys<T0, T1>
7406 where
7407 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7408 T1: ::fidl_next::Encodable<
7409 Encoded = ::fidl_next::ServerEnd<
7410 crate::DictionaryKeysIterator,
7411 ::fidl_next::fuchsia::WireChannel,
7412 >,
7413 >,
7414 {
7415 type Encoded = crate::WireCapabilityStoreDictionaryKeysRequest;
7416 }
7417
7418 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryKeys<T0, T1>
7419 where
7420 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7421 ___E: ::fidl_next::fuchsia::HandleEncoder,
7422 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7423 T1: ::fidl_next::Encode<
7424 ___E,
7425 Encoded = ::fidl_next::ServerEnd<
7426 crate::DictionaryKeysIterator,
7427 ::fidl_next::fuchsia::WireChannel,
7428 >,
7429 >,
7430 {
7431 #[inline]
7432 fn encode(
7433 self,
7434 encoder_: &mut ___E,
7435 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7437 ::fidl_next::munge! {
7438 let Self::Encoded {
7439 id,
7440 iterator,
7441
7442 } = out_;
7443 }
7444
7445 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7446
7447 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7448
7449 Ok(())
7450 }
7451 }
7452
7453 pub struct DictionaryEnumerate<T0, T1> {
7454 id: T0,
7455
7456 iterator: T1,
7457 }
7458
7459 impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerate<T0, T1>
7460 where
7461 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7462 T1: ::fidl_next::Encodable<
7463 Encoded = ::fidl_next::ServerEnd<
7464 crate::DictionaryEnumerateIterator,
7465 ::fidl_next::fuchsia::WireChannel,
7466 >,
7467 >,
7468 {
7469 type Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest;
7470 }
7471
7472 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryEnumerate<T0, T1>
7473 where
7474 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7475 ___E: ::fidl_next::fuchsia::HandleEncoder,
7476 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7477 T1: ::fidl_next::Encode<
7478 ___E,
7479 Encoded = ::fidl_next::ServerEnd<
7480 crate::DictionaryEnumerateIterator,
7481 ::fidl_next::fuchsia::WireChannel,
7482 >,
7483 >,
7484 {
7485 #[inline]
7486 fn encode(
7487 self,
7488 encoder_: &mut ___E,
7489 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7491 ::fidl_next::munge! {
7492 let Self::Encoded {
7493 id,
7494 iterator,
7495
7496 } = out_;
7497 }
7498
7499 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7500
7501 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7502
7503 Ok(())
7504 }
7505 }
7506
7507 pub struct DictionaryDrain<T0, T1> {
7508 id: T0,
7509
7510 iterator: T1,
7511 }
7512
7513 impl<T0, T1> ::fidl_next::Encodable for DictionaryDrain<T0, T1>
7514 where
7515 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7516 T1: ::fidl_next::Encodable<
7517 Encoded = ::fidl_next::ServerEnd<
7518 crate::DictionaryDrainIterator,
7519 ::fidl_next::fuchsia::WireOptionalChannel,
7520 >,
7521 >,
7522 {
7523 type Encoded = crate::WireCapabilityStoreDictionaryDrainRequest;
7524 }
7525
7526 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryDrain<T0, T1>
7527 where
7528 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7529 ___E: ::fidl_next::fuchsia::HandleEncoder,
7530 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7531 T1: ::fidl_next::Encode<
7532 ___E,
7533 Encoded = ::fidl_next::ServerEnd<
7534 crate::DictionaryDrainIterator,
7535 ::fidl_next::fuchsia::WireOptionalChannel,
7536 >,
7537 >,
7538 {
7539 #[inline]
7540 fn encode(
7541 self,
7542 encoder_: &mut ___E,
7543 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7544 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7545 ::fidl_next::munge! {
7546 let Self::Encoded {
7547 id,
7548 iterator,
7549
7550 } = out_;
7551 }
7552
7553 ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7554
7555 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7556
7557 Ok(())
7558 }
7559 }
7560
7561 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::CapabilityStore
7562 where
7563 ___T: ::fidl_next::Transport,
7564 {
7565 type Client = CapabilityStoreClient<___T>;
7566 type Server = CapabilityStoreServer<___T>;
7567 }
7568
7569 #[repr(transparent)]
7571 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
7572 #[allow(dead_code)]
7573 client: ::fidl_next::protocol::Client<___T>,
7574 }
7575
7576 impl<___T> CapabilityStoreClient<___T>
7577 where
7578 ___T: ::fidl_next::Transport,
7579 {
7580 #[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"]
7581 pub fn duplicate(
7582 &self,
7583
7584 id: impl ::fidl_next::Encode<
7585 <___T as ::fidl_next::Transport>::SendBuffer,
7586 Encoded = ::fidl_next::WireU64,
7587 >,
7588
7589 dest_id: impl ::fidl_next::Encode<
7590 <___T as ::fidl_next::Transport>::SendBuffer,
7591 Encoded = ::fidl_next::WireU64,
7592 >,
7593 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
7594 where
7595 <___T as ::fidl_next::Transport>::SendBuffer:
7596 ::fidl_next::encoder::InternalHandleEncoder,
7597 {
7598 self.duplicate_with(Duplicate { id, dest_id })
7599 }
7600
7601 #[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"]
7602 pub fn duplicate_with<___R>(
7603 &self,
7604 request: ___R,
7605 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
7606 where
7607 ___R: ::fidl_next::Encode<
7608 <___T as ::fidl_next::Transport>::SendBuffer,
7609 Encoded = crate::WireCapabilityStoreDuplicateRequest,
7610 >,
7611 {
7612 ::fidl_next::TwoWayFuture::from_untyped(
7613 self.client.send_two_way(6727592627741008260, request),
7614 )
7615 }
7616
7617 #[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"]
7618 pub fn drop(
7619 &self,
7620
7621 id: impl ::fidl_next::Encode<
7622 <___T as ::fidl_next::Transport>::SendBuffer,
7623 Encoded = ::fidl_next::WireU64,
7624 >,
7625 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
7626 where
7627 <___T as ::fidl_next::Transport>::SendBuffer:
7628 ::fidl_next::encoder::InternalHandleEncoder,
7629 {
7630 self.drop_with(Drop { id })
7631 }
7632
7633 #[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"]
7634 pub fn drop_with<___R>(
7635 &self,
7636 request: ___R,
7637 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
7638 where
7639 ___R: ::fidl_next::Encode<
7640 <___T as ::fidl_next::Transport>::SendBuffer,
7641 Encoded = crate::WireCapabilityStoreDropRequest,
7642 >,
7643 {
7644 ::fidl_next::TwoWayFuture::from_untyped(
7645 self.client.send_two_way(753328233834620249, request),
7646 )
7647 }
7648
7649 #[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"]
7650 pub fn export(
7651 &self,
7652
7653 id: impl ::fidl_next::Encode<
7654 <___T as ::fidl_next::Transport>::SendBuffer,
7655 Encoded = ::fidl_next::WireU64,
7656 >,
7657 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
7658 where
7659 <___T as ::fidl_next::Transport>::SendBuffer:
7660 ::fidl_next::encoder::InternalHandleEncoder,
7661 {
7662 self.export_with(Export { id })
7663 }
7664
7665 #[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"]
7666 pub fn export_with<___R>(
7667 &self,
7668 request: ___R,
7669 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
7670 where
7671 ___R: ::fidl_next::Encode<
7672 <___T as ::fidl_next::Transport>::SendBuffer,
7673 Encoded = crate::WireCapabilityStoreExportRequest,
7674 >,
7675 {
7676 ::fidl_next::TwoWayFuture::from_untyped(
7677 self.client.send_two_way(226159162093533951, request),
7678 )
7679 }
7680
7681 #[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"]
7682 pub fn import(
7683 &self,
7684
7685 id: impl ::fidl_next::Encode<
7686 <___T as ::fidl_next::Transport>::SendBuffer,
7687 Encoded = ::fidl_next::WireU64,
7688 >,
7689
7690 capability: impl ::fidl_next::Encode<
7691 <___T as ::fidl_next::Transport>::SendBuffer,
7692 Encoded = crate::WireCapability<'static>,
7693 >,
7694 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
7695 where
7696 <___T as ::fidl_next::Transport>::SendBuffer:
7697 ::fidl_next::encoder::InternalHandleEncoder,
7698 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7699 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7700 {
7701 self.import_with(Import { id, capability })
7702 }
7703
7704 #[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"]
7705 pub fn import_with<___R>(
7706 &self,
7707 request: ___R,
7708 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
7709 where
7710 ___R: ::fidl_next::Encode<
7711 <___T as ::fidl_next::Transport>::SendBuffer,
7712 Encoded = crate::WireCapabilityStoreImportRequest<'static>,
7713 >,
7714 {
7715 ::fidl_next::TwoWayFuture::from_untyped(
7716 self.client.send_two_way(2276030276116435867, request),
7717 )
7718 }
7719
7720 #[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"]
7721 pub fn connector_create(
7722 &self,
7723
7724 id: impl ::fidl_next::Encode<
7725 <___T as ::fidl_next::Transport>::SendBuffer,
7726 Encoded = ::fidl_next::WireU64,
7727 >,
7728
7729 receiver: impl ::fidl_next::Encode<
7730 <___T as ::fidl_next::Transport>::SendBuffer,
7731 Encoded = ::fidl_next::ClientEnd<
7732 crate::Receiver,
7733 ::fidl_next::fuchsia::WireChannel,
7734 >,
7735 >,
7736 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
7737 where
7738 <___T as ::fidl_next::Transport>::SendBuffer:
7739 ::fidl_next::encoder::InternalHandleEncoder,
7740 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7741 {
7742 self.connector_create_with(ConnectorCreate { id, receiver })
7743 }
7744
7745 #[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"]
7746 pub fn connector_create_with<___R>(
7747 &self,
7748 request: ___R,
7749 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
7750 where
7751 ___R: ::fidl_next::Encode<
7752 <___T as ::fidl_next::Transport>::SendBuffer,
7753 Encoded = crate::WireCapabilityStoreConnectorCreateRequest,
7754 >,
7755 {
7756 ::fidl_next::TwoWayFuture::from_untyped(
7757 self.client.send_two_way(2979461408102095909, request),
7758 )
7759 }
7760
7761 #[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"]
7762 pub fn connector_open(
7763 &self,
7764
7765 id: impl ::fidl_next::Encode<
7766 <___T as ::fidl_next::Transport>::SendBuffer,
7767 Encoded = ::fidl_next::WireU64,
7768 >,
7769
7770 server_end: impl ::fidl_next::Encode<
7771 <___T as ::fidl_next::Transport>::SendBuffer,
7772 Encoded = ::fidl_next::fuchsia::WireChannel,
7773 >,
7774 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
7775 where
7776 <___T as ::fidl_next::Transport>::SendBuffer:
7777 ::fidl_next::encoder::InternalHandleEncoder,
7778 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7779 {
7780 self.connector_open_with(ConnectorOpen { id, server_end })
7781 }
7782
7783 #[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"]
7784 pub fn connector_open_with<___R>(
7785 &self,
7786 request: ___R,
7787 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
7788 where
7789 ___R: ::fidl_next::Encode<
7790 <___T as ::fidl_next::Transport>::SendBuffer,
7791 Encoded = crate::WireCapabilityStoreConnectorOpenRequest,
7792 >,
7793 {
7794 ::fidl_next::TwoWayFuture::from_untyped(
7795 self.client.send_two_way(6016362336453278623, request),
7796 )
7797 }
7798
7799 #[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"]
7800 pub fn dir_connector_create(
7801 &self,
7802
7803 id: impl ::fidl_next::Encode<
7804 <___T as ::fidl_next::Transport>::SendBuffer,
7805 Encoded = ::fidl_next::WireU64,
7806 >,
7807
7808 receiver: impl ::fidl_next::Encode<
7809 <___T as ::fidl_next::Transport>::SendBuffer,
7810 Encoded = ::fidl_next::ClientEnd<
7811 crate::DirReceiver,
7812 ::fidl_next::fuchsia::WireChannel,
7813 >,
7814 >,
7815 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
7816 where
7817 <___T as ::fidl_next::Transport>::SendBuffer:
7818 ::fidl_next::encoder::InternalHandleEncoder,
7819 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7820 {
7821 self.dir_connector_create_with(DirConnectorCreate { id, receiver })
7822 }
7823
7824 #[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"]
7825 pub fn dir_connector_create_with<___R>(
7826 &self,
7827 request: ___R,
7828 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
7829 where
7830 ___R: ::fidl_next::Encode<
7831 <___T as ::fidl_next::Transport>::SendBuffer,
7832 Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest,
7833 >,
7834 {
7835 ::fidl_next::TwoWayFuture::from_untyped(
7836 self.client.send_two_way(1756747594275428795, request),
7837 )
7838 }
7839
7840 #[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"]
7841 pub fn dir_connector_open(
7842 &self,
7843
7844 id: impl ::fidl_next::Encode<
7845 <___T as ::fidl_next::Transport>::SendBuffer,
7846 Encoded = ::fidl_next::WireU64,
7847 >,
7848
7849 server_end: impl ::fidl_next::Encode<
7850 <___T as ::fidl_next::Transport>::SendBuffer,
7851 Encoded = ::fidl_next::ServerEnd<
7852 ::fidl_next_fuchsia_io::Directory,
7853 ::fidl_next::fuchsia::WireChannel,
7854 >,
7855 >,
7856 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
7857 where
7858 <___T as ::fidl_next::Transport>::SendBuffer:
7859 ::fidl_next::encoder::InternalHandleEncoder,
7860 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7861 {
7862 self.dir_connector_open_with(DirConnectorOpen { id, server_end })
7863 }
7864
7865 #[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"]
7866 pub fn dir_connector_open_with<___R>(
7867 &self,
7868 request: ___R,
7869 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
7870 where
7871 ___R: ::fidl_next::Encode<
7872 <___T as ::fidl_next::Transport>::SendBuffer,
7873 Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest,
7874 >,
7875 {
7876 ::fidl_next::TwoWayFuture::from_untyped(
7877 self.client.send_two_way(6219704004220369153, request),
7878 )
7879 }
7880
7881 #[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"]
7882 pub fn dictionary_create(
7883 &self,
7884
7885 id: impl ::fidl_next::Encode<
7886 <___T as ::fidl_next::Transport>::SendBuffer,
7887 Encoded = ::fidl_next::WireU64,
7888 >,
7889 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
7890 where
7891 <___T as ::fidl_next::Transport>::SendBuffer:
7892 ::fidl_next::encoder::InternalHandleEncoder,
7893 {
7894 self.dictionary_create_with(DictionaryCreate { id })
7895 }
7896
7897 #[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"]
7898 pub fn dictionary_create_with<___R>(
7899 &self,
7900 request: ___R,
7901 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
7902 where
7903 ___R: ::fidl_next::Encode<
7904 <___T as ::fidl_next::Transport>::SendBuffer,
7905 Encoded = crate::WireCapabilityStoreDictionaryCreateRequest,
7906 >,
7907 {
7908 ::fidl_next::TwoWayFuture::from_untyped(
7909 self.client.send_two_way(7608770958894948499, request),
7910 )
7911 }
7912
7913 #[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"]
7914 pub fn dictionary_legacy_import(
7915 &self,
7916
7917 id: impl ::fidl_next::Encode<
7918 <___T as ::fidl_next::Transport>::SendBuffer,
7919 Encoded = ::fidl_next::WireU64,
7920 >,
7921
7922 client_end: impl ::fidl_next::Encode<
7923 <___T as ::fidl_next::Transport>::SendBuffer,
7924 Encoded = ::fidl_next::fuchsia::WireChannel,
7925 >,
7926 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
7927 where
7928 <___T as ::fidl_next::Transport>::SendBuffer:
7929 ::fidl_next::encoder::InternalHandleEncoder,
7930 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7931 {
7932 self.dictionary_legacy_import_with(DictionaryLegacyImport { id, client_end })
7933 }
7934
7935 #[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"]
7936 pub fn dictionary_legacy_import_with<___R>(
7937 &self,
7938 request: ___R,
7939 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
7940 where
7941 ___R: ::fidl_next::Encode<
7942 <___T as ::fidl_next::Transport>::SendBuffer,
7943 Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest,
7944 >,
7945 {
7946 ::fidl_next::TwoWayFuture::from_untyped(
7947 self.client.send_two_way(8285893703432012383, request),
7948 )
7949 }
7950
7951 #[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"]
7952 pub fn dictionary_legacy_export(
7953 &self,
7954
7955 id: impl ::fidl_next::Encode<
7956 <___T as ::fidl_next::Transport>::SendBuffer,
7957 Encoded = ::fidl_next::WireU64,
7958 >,
7959
7960 server_end: impl ::fidl_next::Encode<
7961 <___T as ::fidl_next::Transport>::SendBuffer,
7962 Encoded = ::fidl_next::fuchsia::WireChannel,
7963 >,
7964 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
7965 where
7966 <___T as ::fidl_next::Transport>::SendBuffer:
7967 ::fidl_next::encoder::InternalHandleEncoder,
7968 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7969 {
7970 self.dictionary_legacy_export_with(DictionaryLegacyExport { id, server_end })
7971 }
7972
7973 #[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"]
7974 pub fn dictionary_legacy_export_with<___R>(
7975 &self,
7976 request: ___R,
7977 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
7978 where
7979 ___R: ::fidl_next::Encode<
7980 <___T as ::fidl_next::Transport>::SendBuffer,
7981 Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest,
7982 >,
7983 {
7984 ::fidl_next::TwoWayFuture::from_untyped(
7985 self.client.send_two_way(4647175832683306445, request),
7986 )
7987 }
7988
7989 #[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"]
7990 pub fn dictionary_insert(
7991 &self,
7992
7993 id: impl ::fidl_next::Encode<
7994 <___T as ::fidl_next::Transport>::SendBuffer,
7995 Encoded = ::fidl_next::WireU64,
7996 >,
7997
7998 item: impl ::fidl_next::Encode<
7999 <___T as ::fidl_next::Transport>::SendBuffer,
8000 Encoded = crate::WireDictionaryItem<'static>,
8001 >,
8002 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8003 where
8004 <___T as ::fidl_next::Transport>::SendBuffer:
8005 ::fidl_next::encoder::InternalHandleEncoder,
8006 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8007 {
8008 self.dictionary_insert_with(DictionaryInsert { id, item })
8009 }
8010
8011 #[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"]
8012 pub fn dictionary_insert_with<___R>(
8013 &self,
8014 request: ___R,
8015 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8016 where
8017 ___R: ::fidl_next::Encode<
8018 <___T as ::fidl_next::Transport>::SendBuffer,
8019 Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>,
8020 >,
8021 {
8022 ::fidl_next::TwoWayFuture::from_untyped(
8023 self.client.send_two_way(8575443262986538023, request),
8024 )
8025 }
8026
8027 #[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"]
8028 pub fn dictionary_get(
8029 &self,
8030
8031 id: impl ::fidl_next::Encode<
8032 <___T as ::fidl_next::Transport>::SendBuffer,
8033 Encoded = ::fidl_next::WireU64,
8034 >,
8035
8036 key: impl ::fidl_next::Encode<
8037 <___T as ::fidl_next::Transport>::SendBuffer,
8038 Encoded = ::fidl_next::WireString<'static>,
8039 >,
8040
8041 dest_id: impl ::fidl_next::Encode<
8042 <___T as ::fidl_next::Transport>::SendBuffer,
8043 Encoded = ::fidl_next::WireU64,
8044 >,
8045 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8046 where
8047 <___T as ::fidl_next::Transport>::SendBuffer:
8048 ::fidl_next::encoder::InternalHandleEncoder,
8049 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8050 {
8051 self.dictionary_get_with(DictionaryGet { id, key, dest_id })
8052 }
8053
8054 #[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"]
8055 pub fn dictionary_get_with<___R>(
8056 &self,
8057 request: ___R,
8058 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8059 where
8060 ___R: ::fidl_next::Encode<
8061 <___T as ::fidl_next::Transport>::SendBuffer,
8062 Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>,
8063 >,
8064 {
8065 ::fidl_next::TwoWayFuture::from_untyped(
8066 self.client.send_two_way(5592951026866236882, request),
8067 )
8068 }
8069
8070 #[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"]
8071 pub fn dictionary_remove(
8072 &self,
8073
8074 id: impl ::fidl_next::Encode<
8075 <___T as ::fidl_next::Transport>::SendBuffer,
8076 Encoded = ::fidl_next::WireU64,
8077 >,
8078
8079 key: impl ::fidl_next::Encode<
8080 <___T as ::fidl_next::Transport>::SendBuffer,
8081 Encoded = ::fidl_next::WireString<'static>,
8082 >,
8083
8084 dest_id: impl ::fidl_next::Encode<
8085 <___T as ::fidl_next::Transport>::SendBuffer,
8086 Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
8087 >,
8088 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8089 where
8090 <___T as ::fidl_next::Transport>::SendBuffer:
8091 ::fidl_next::encoder::InternalHandleEncoder,
8092 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8093 {
8094 self.dictionary_remove_with(DictionaryRemove { id, key, dest_id })
8095 }
8096
8097 #[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"]
8098 pub fn dictionary_remove_with<___R>(
8099 &self,
8100 request: ___R,
8101 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8102 where
8103 ___R: ::fidl_next::Encode<
8104 <___T as ::fidl_next::Transport>::SendBuffer,
8105 Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>,
8106 >,
8107 {
8108 ::fidl_next::TwoWayFuture::from_untyped(
8109 self.client.send_two_way(343892214579320051, request),
8110 )
8111 }
8112
8113 #[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"]
8114 pub fn dictionary_copy(
8115 &self,
8116
8117 id: impl ::fidl_next::Encode<
8118 <___T as ::fidl_next::Transport>::SendBuffer,
8119 Encoded = ::fidl_next::WireU64,
8120 >,
8121
8122 dest_id: impl ::fidl_next::Encode<
8123 <___T as ::fidl_next::Transport>::SendBuffer,
8124 Encoded = ::fidl_next::WireU64,
8125 >,
8126 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
8127 where
8128 <___T as ::fidl_next::Transport>::SendBuffer:
8129 ::fidl_next::encoder::InternalHandleEncoder,
8130 {
8131 self.dictionary_copy_with(DictionaryCopy { id, dest_id })
8132 }
8133
8134 #[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"]
8135 pub fn dictionary_copy_with<___R>(
8136 &self,
8137 request: ___R,
8138 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
8139 where
8140 ___R: ::fidl_next::Encode<
8141 <___T as ::fidl_next::Transport>::SendBuffer,
8142 Encoded = crate::WireCapabilityStoreDictionaryCopyRequest,
8143 >,
8144 {
8145 ::fidl_next::TwoWayFuture::from_untyped(
8146 self.client.send_two_way(3977783339739362383, request),
8147 )
8148 }
8149
8150 #[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"]
8151 pub fn dictionary_keys(
8152 &self,
8153
8154 id: impl ::fidl_next::Encode<
8155 <___T as ::fidl_next::Transport>::SendBuffer,
8156 Encoded = ::fidl_next::WireU64,
8157 >,
8158
8159 iterator: impl ::fidl_next::Encode<
8160 <___T as ::fidl_next::Transport>::SendBuffer,
8161 Encoded = ::fidl_next::ServerEnd<
8162 crate::DictionaryKeysIterator,
8163 ::fidl_next::fuchsia::WireChannel,
8164 >,
8165 >,
8166 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
8167 where
8168 <___T as ::fidl_next::Transport>::SendBuffer:
8169 ::fidl_next::encoder::InternalHandleEncoder,
8170 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8171 {
8172 self.dictionary_keys_with(DictionaryKeys { id, iterator })
8173 }
8174
8175 #[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"]
8176 pub fn dictionary_keys_with<___R>(
8177 &self,
8178 request: ___R,
8179 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
8180 where
8181 ___R: ::fidl_next::Encode<
8182 <___T as ::fidl_next::Transport>::SendBuffer,
8183 Encoded = crate::WireCapabilityStoreDictionaryKeysRequest,
8184 >,
8185 {
8186 ::fidl_next::TwoWayFuture::from_untyped(
8187 self.client.send_two_way(597577248872787102, request),
8188 )
8189 }
8190
8191 #[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"]
8192 pub fn dictionary_enumerate(
8193 &self,
8194
8195 id: impl ::fidl_next::Encode<
8196 <___T as ::fidl_next::Transport>::SendBuffer,
8197 Encoded = ::fidl_next::WireU64,
8198 >,
8199
8200 iterator: impl ::fidl_next::Encode<
8201 <___T as ::fidl_next::Transport>::SendBuffer,
8202 Encoded = ::fidl_next::ServerEnd<
8203 crate::DictionaryEnumerateIterator,
8204 ::fidl_next::fuchsia::WireChannel,
8205 >,
8206 >,
8207 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
8208 where
8209 <___T as ::fidl_next::Transport>::SendBuffer:
8210 ::fidl_next::encoder::InternalHandleEncoder,
8211 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8212 {
8213 self.dictionary_enumerate_with(DictionaryEnumerate { id, iterator })
8214 }
8215
8216 #[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"]
8217 pub fn dictionary_enumerate_with<___R>(
8218 &self,
8219 request: ___R,
8220 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
8221 where
8222 ___R: ::fidl_next::Encode<
8223 <___T as ::fidl_next::Transport>::SendBuffer,
8224 Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest,
8225 >,
8226 {
8227 ::fidl_next::TwoWayFuture::from_untyped(
8228 self.client.send_two_way(964467096271472193, request),
8229 )
8230 }
8231
8232 #[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"]
8233 pub fn dictionary_drain(
8234 &self,
8235
8236 id: impl ::fidl_next::Encode<
8237 <___T as ::fidl_next::Transport>::SendBuffer,
8238 Encoded = ::fidl_next::WireU64,
8239 >,
8240
8241 iterator: impl ::fidl_next::Encode<
8242 <___T as ::fidl_next::Transport>::SendBuffer,
8243 Encoded = ::fidl_next::ServerEnd<
8244 crate::DictionaryDrainIterator,
8245 ::fidl_next::fuchsia::WireOptionalChannel,
8246 >,
8247 >,
8248 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
8249 where
8250 <___T as ::fidl_next::Transport>::SendBuffer:
8251 ::fidl_next::encoder::InternalHandleEncoder,
8252 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8253 {
8254 self.dictionary_drain_with(DictionaryDrain { id, iterator })
8255 }
8256
8257 #[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"]
8258 pub fn dictionary_drain_with<___R>(
8259 &self,
8260 request: ___R,
8261 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
8262 where
8263 ___R: ::fidl_next::Encode<
8264 <___T as ::fidl_next::Transport>::SendBuffer,
8265 Encoded = crate::WireCapabilityStoreDictionaryDrainRequest,
8266 >,
8267 {
8268 ::fidl_next::TwoWayFuture::from_untyped(
8269 self.client.send_two_way(2928364469569621208, request),
8270 )
8271 }
8272 }
8273
8274 #[repr(transparent)]
8276 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
8277 server: ::fidl_next::protocol::Server<___T>,
8278 }
8279
8280 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
8281 }
8282}
8283
8284pub trait CapabilityStoreClientHandler<
8288 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
8289 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8290>
8291{
8292 fn on_unknown_interaction(
8293 &mut self,
8294 ordinal: u64,
8295 ) -> impl ::core::future::Future<
8296 Output = ::core::result::Result<
8297 (),
8298 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8299 >,
8300 > + ::core::marker::Send {
8301 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
8302 }
8303}
8304
8305impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
8306where
8307 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
8308 ___T: ::fidl_next::Transport,
8309 <capability_store::Duplicate as ::fidl_next::Method>::Response:
8310 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8311 <capability_store::Drop as ::fidl_next::Method>::Response:
8312 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8313 <capability_store::Export as ::fidl_next::Method>::Response:
8314 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8315 <capability_store::Import as ::fidl_next::Method>::Response:
8316 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8317 <capability_store::ConnectorCreate as ::fidl_next::Method>::Response:
8318 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8319 <capability_store::ConnectorOpen as ::fidl_next::Method>::Response:
8320 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8321 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Response:
8322 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8323 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Response:
8324 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8325 <capability_store::DictionaryCreate as ::fidl_next::Method>::Response:
8326 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8327 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Response:
8328 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8329 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Response:
8330 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8331 <capability_store::DictionaryInsert as ::fidl_next::Method>::Response:
8332 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8333 <capability_store::DictionaryGet as ::fidl_next::Method>::Response:
8334 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8335 <capability_store::DictionaryRemove as ::fidl_next::Method>::Response:
8336 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8337 <capability_store::DictionaryCopy as ::fidl_next::Method>::Response:
8338 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8339 <capability_store::DictionaryKeys as ::fidl_next::Method>::Response:
8340 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8341 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Response:
8342 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8343 <capability_store::DictionaryDrain as ::fidl_next::Method>::Response:
8344 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8345{
8346 async fn on_event(
8347 handler: &mut ___H,
8348 ordinal: u64,
8349 buffer: ___T::RecvBuffer,
8350 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8351 match ordinal {
8352 ordinal => handler.on_unknown_interaction(ordinal).await,
8353 }
8354 }
8355}
8356
8357pub trait CapabilityStoreServerHandler<
8361 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
8362 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8363>
8364{
8365 #[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"]
8366 fn duplicate(
8367 &mut self,
8368
8369 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
8370
8371 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
8372 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8373
8374 #[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"]
8375 fn drop(
8376 &mut self,
8377
8378 request: ::fidl_next::Request<capability_store::Drop, ___T>,
8379
8380 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
8381 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8382
8383 #[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"]
8384 fn export(
8385 &mut self,
8386
8387 request: ::fidl_next::Request<capability_store::Export, ___T>,
8388
8389 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
8390 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8391
8392 #[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"]
8393 fn import(
8394 &mut self,
8395
8396 request: ::fidl_next::Request<capability_store::Import, ___T>,
8397
8398 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
8399 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8400
8401 #[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"]
8402 fn connector_create(
8403 &mut self,
8404
8405 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
8406
8407 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
8408 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8409
8410 #[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"]
8411 fn connector_open(
8412 &mut self,
8413
8414 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
8415
8416 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
8417 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8418
8419 #[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"]
8420 fn dir_connector_create(
8421 &mut self,
8422
8423 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
8424
8425 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
8426 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8427
8428 #[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"]
8429 fn dir_connector_open(
8430 &mut self,
8431
8432 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
8433
8434 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
8435 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8436
8437 #[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"]
8438 fn dictionary_create(
8439 &mut self,
8440
8441 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
8442
8443 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
8444 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8445
8446 #[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"]
8447 fn dictionary_legacy_import(
8448 &mut self,
8449
8450 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
8451
8452 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
8453 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8454
8455 #[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"]
8456 fn dictionary_legacy_export(
8457 &mut self,
8458
8459 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
8460
8461 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
8462 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8463
8464 #[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"]
8465 fn dictionary_insert(
8466 &mut self,
8467
8468 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
8469
8470 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
8471 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8472
8473 #[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"]
8474 fn dictionary_get(
8475 &mut self,
8476
8477 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
8478
8479 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
8480 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8481
8482 #[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"]
8483 fn dictionary_remove(
8484 &mut self,
8485
8486 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
8487
8488 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
8489 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8490
8491 #[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"]
8492 fn dictionary_copy(
8493 &mut self,
8494
8495 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
8496
8497 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
8498 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8499
8500 #[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"]
8501 fn dictionary_keys(
8502 &mut self,
8503
8504 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
8505
8506 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
8507 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8508
8509 #[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"]
8510 fn dictionary_enumerate(
8511 &mut self,
8512
8513 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
8514
8515 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
8516 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8517
8518 #[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"]
8519 fn dictionary_drain(
8520 &mut self,
8521
8522 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
8523
8524 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
8525 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8526
8527 fn on_unknown_interaction(
8528 &mut self,
8529 ordinal: u64,
8530 ) -> impl ::core::future::Future<
8531 Output = ::core::result::Result<
8532 (),
8533 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8534 >,
8535 > + ::core::marker::Send {
8536 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
8537 }
8538}
8539
8540impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
8541where
8542 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
8543 ___T: ::fidl_next::Transport,
8544 <capability_store::Duplicate as ::fidl_next::Method>::Request:
8545 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8546 <capability_store::Drop as ::fidl_next::Method>::Request:
8547 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8548 <capability_store::Export as ::fidl_next::Method>::Request:
8549 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8550 <capability_store::Import as ::fidl_next::Method>::Request:
8551 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8552 <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
8553 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8554 <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
8555 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8556 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
8557 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8558 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
8559 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8560 <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
8561 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8562 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
8563 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8564 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
8565 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8566 <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
8567 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8568 <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
8569 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8570 <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
8571 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8572 <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
8573 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8574 <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
8575 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8576 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
8577 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8578 <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
8579 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8580{
8581 async fn on_one_way(
8582 handler: &mut ___H,
8583 ordinal: u64,
8584 buffer: ___T::RecvBuffer,
8585 ) -> ::core::result::Result<
8586 (),
8587 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8588 > {
8589 match ordinal {
8590 ordinal => handler.on_unknown_interaction(ordinal).await,
8591 }
8592 }
8593
8594 async fn on_two_way(
8595 handler: &mut ___H,
8596 ordinal: u64,
8597 buffer: ___T::RecvBuffer,
8598 responder: ::fidl_next::protocol::Responder<___T>,
8599 ) -> ::core::result::Result<
8600 (),
8601 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8602 > {
8603 match ordinal {
8604 6727592627741008260 => {
8605 let responder = ::fidl_next::Responder::from_untyped(responder);
8606
8607 match ::fidl_next::DecoderExt::decode(buffer) {
8608 Ok(decoded) => {
8609 handler.duplicate(decoded, responder).await;
8610 Ok(())
8611 }
8612 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8613 ordinal: 6727592627741008260,
8614 error,
8615 }),
8616 }
8617 }
8618
8619 753328233834620249 => {
8620 let responder = ::fidl_next::Responder::from_untyped(responder);
8621
8622 match ::fidl_next::DecoderExt::decode(buffer) {
8623 Ok(decoded) => {
8624 handler.drop(decoded, responder).await;
8625 Ok(())
8626 }
8627 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8628 ordinal: 753328233834620249,
8629 error,
8630 }),
8631 }
8632 }
8633
8634 226159162093533951 => {
8635 let responder = ::fidl_next::Responder::from_untyped(responder);
8636
8637 match ::fidl_next::DecoderExt::decode(buffer) {
8638 Ok(decoded) => {
8639 handler.export(decoded, responder).await;
8640 Ok(())
8641 }
8642 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8643 ordinal: 226159162093533951,
8644 error,
8645 }),
8646 }
8647 }
8648
8649 2276030276116435867 => {
8650 let responder = ::fidl_next::Responder::from_untyped(responder);
8651
8652 match ::fidl_next::DecoderExt::decode(buffer) {
8653 Ok(decoded) => {
8654 handler.import(decoded, responder).await;
8655 Ok(())
8656 }
8657 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8658 ordinal: 2276030276116435867,
8659 error,
8660 }),
8661 }
8662 }
8663
8664 2979461408102095909 => {
8665 let responder = ::fidl_next::Responder::from_untyped(responder);
8666
8667 match ::fidl_next::DecoderExt::decode(buffer) {
8668 Ok(decoded) => {
8669 handler.connector_create(decoded, responder).await;
8670 Ok(())
8671 }
8672 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8673 ordinal: 2979461408102095909,
8674 error,
8675 }),
8676 }
8677 }
8678
8679 6016362336453278623 => {
8680 let responder = ::fidl_next::Responder::from_untyped(responder);
8681
8682 match ::fidl_next::DecoderExt::decode(buffer) {
8683 Ok(decoded) => {
8684 handler.connector_open(decoded, responder).await;
8685 Ok(())
8686 }
8687 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8688 ordinal: 6016362336453278623,
8689 error,
8690 }),
8691 }
8692 }
8693
8694 1756747594275428795 => {
8695 let responder = ::fidl_next::Responder::from_untyped(responder);
8696
8697 match ::fidl_next::DecoderExt::decode(buffer) {
8698 Ok(decoded) => {
8699 handler.dir_connector_create(decoded, responder).await;
8700 Ok(())
8701 }
8702 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8703 ordinal: 1756747594275428795,
8704 error,
8705 }),
8706 }
8707 }
8708
8709 6219704004220369153 => {
8710 let responder = ::fidl_next::Responder::from_untyped(responder);
8711
8712 match ::fidl_next::DecoderExt::decode(buffer) {
8713 Ok(decoded) => {
8714 handler.dir_connector_open(decoded, responder).await;
8715 Ok(())
8716 }
8717 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8718 ordinal: 6219704004220369153,
8719 error,
8720 }),
8721 }
8722 }
8723
8724 7608770958894948499 => {
8725 let responder = ::fidl_next::Responder::from_untyped(responder);
8726
8727 match ::fidl_next::DecoderExt::decode(buffer) {
8728 Ok(decoded) => {
8729 handler.dictionary_create(decoded, responder).await;
8730 Ok(())
8731 }
8732 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8733 ordinal: 7608770958894948499,
8734 error,
8735 }),
8736 }
8737 }
8738
8739 8285893703432012383 => {
8740 let responder = ::fidl_next::Responder::from_untyped(responder);
8741
8742 match ::fidl_next::DecoderExt::decode(buffer) {
8743 Ok(decoded) => {
8744 handler.dictionary_legacy_import(decoded, responder).await;
8745 Ok(())
8746 }
8747 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8748 ordinal: 8285893703432012383,
8749 error,
8750 }),
8751 }
8752 }
8753
8754 4647175832683306445 => {
8755 let responder = ::fidl_next::Responder::from_untyped(responder);
8756
8757 match ::fidl_next::DecoderExt::decode(buffer) {
8758 Ok(decoded) => {
8759 handler.dictionary_legacy_export(decoded, responder).await;
8760 Ok(())
8761 }
8762 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8763 ordinal: 4647175832683306445,
8764 error,
8765 }),
8766 }
8767 }
8768
8769 8575443262986538023 => {
8770 let responder = ::fidl_next::Responder::from_untyped(responder);
8771
8772 match ::fidl_next::DecoderExt::decode(buffer) {
8773 Ok(decoded) => {
8774 handler.dictionary_insert(decoded, responder).await;
8775 Ok(())
8776 }
8777 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8778 ordinal: 8575443262986538023,
8779 error,
8780 }),
8781 }
8782 }
8783
8784 5592951026866236882 => {
8785 let responder = ::fidl_next::Responder::from_untyped(responder);
8786
8787 match ::fidl_next::DecoderExt::decode(buffer) {
8788 Ok(decoded) => {
8789 handler.dictionary_get(decoded, responder).await;
8790 Ok(())
8791 }
8792 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8793 ordinal: 5592951026866236882,
8794 error,
8795 }),
8796 }
8797 }
8798
8799 343892214579320051 => {
8800 let responder = ::fidl_next::Responder::from_untyped(responder);
8801
8802 match ::fidl_next::DecoderExt::decode(buffer) {
8803 Ok(decoded) => {
8804 handler.dictionary_remove(decoded, responder).await;
8805 Ok(())
8806 }
8807 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8808 ordinal: 343892214579320051,
8809 error,
8810 }),
8811 }
8812 }
8813
8814 3977783339739362383 => {
8815 let responder = ::fidl_next::Responder::from_untyped(responder);
8816
8817 match ::fidl_next::DecoderExt::decode(buffer) {
8818 Ok(decoded) => {
8819 handler.dictionary_copy(decoded, responder).await;
8820 Ok(())
8821 }
8822 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8823 ordinal: 3977783339739362383,
8824 error,
8825 }),
8826 }
8827 }
8828
8829 597577248872787102 => {
8830 let responder = ::fidl_next::Responder::from_untyped(responder);
8831
8832 match ::fidl_next::DecoderExt::decode(buffer) {
8833 Ok(decoded) => {
8834 handler.dictionary_keys(decoded, responder).await;
8835 Ok(())
8836 }
8837 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8838 ordinal: 597577248872787102,
8839 error,
8840 }),
8841 }
8842 }
8843
8844 964467096271472193 => {
8845 let responder = ::fidl_next::Responder::from_untyped(responder);
8846
8847 match ::fidl_next::DecoderExt::decode(buffer) {
8848 Ok(decoded) => {
8849 handler.dictionary_enumerate(decoded, responder).await;
8850 Ok(())
8851 }
8852 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8853 ordinal: 964467096271472193,
8854 error,
8855 }),
8856 }
8857 }
8858
8859 2928364469569621208 => {
8860 let responder = ::fidl_next::Responder::from_untyped(responder);
8861
8862 match ::fidl_next::DecoderExt::decode(buffer) {
8863 Ok(decoded) => {
8864 handler.dictionary_drain(decoded, responder).await;
8865 Ok(())
8866 }
8867 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8868 ordinal: 2928364469569621208,
8869 error,
8870 }),
8871 }
8872 }
8873
8874 ordinal => handler.on_unknown_interaction(ordinal).await,
8875 }
8876 }
8877}
8878
8879#[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
8880#[derive(PartialEq, Debug)]
8881#[repr(C)]
8882pub struct InstanceToken {
8883 pub token: ::fidl_next::fuchsia::zx::EventPair,
8884}
8885
8886impl ::fidl_next::Encodable for InstanceToken {
8887 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireInstanceToken> = unsafe {
8888 ::fidl_next::CopyOptimization::enable_if(
8889 true
8890
8891 && <
8892 ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
8893 >::COPY_OPTIMIZATION.is_enabled()
8894
8895 )
8896 };
8897
8898 type Encoded = WireInstanceToken;
8899}
8900
8901unsafe impl<___E> ::fidl_next::Encode<___E> for InstanceToken
8902where
8903 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8904 ___E: ::fidl_next::fuchsia::HandleEncoder,
8905{
8906 #[inline]
8907 fn encode(
8908 self,
8909 encoder_: &mut ___E,
8910 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
8911 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8912 ::fidl_next::munge! {
8913 let Self::Encoded {
8914 token,
8915
8916 } = out_;
8917 }
8918
8919 ::fidl_next::Encode::encode(self.token, encoder_, token)?;
8920
8921 Ok(())
8922 }
8923}
8924
8925impl ::fidl_next::EncodableOption for InstanceToken {
8926 type EncodedOption = ::fidl_next::WireBox<'static, WireInstanceToken>;
8927}
8928
8929unsafe impl<___E> ::fidl_next::EncodeOption<___E> for InstanceToken
8930where
8931 ___E: ::fidl_next::Encoder + ?Sized,
8932 InstanceToken: ::fidl_next::Encode<___E>,
8933{
8934 #[inline]
8935 fn encode_option(
8936 this: ::core::option::Option<Self>,
8937 encoder: &mut ___E,
8938 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
8939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8940 if let Some(inner) = this {
8941 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8942 ::fidl_next::WireBox::encode_present(out);
8943 } else {
8944 ::fidl_next::WireBox::encode_absent(out);
8945 }
8946
8947 Ok(())
8948 }
8949}
8950
8951impl ::fidl_next::FromWire<WireInstanceToken> for InstanceToken {
8952 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireInstanceToken, Self> = unsafe {
8953 ::fidl_next::CopyOptimization::enable_if(
8954 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
8955 ::fidl_next::fuchsia::WireEventPair,
8956 >>::COPY_OPTIMIZATION
8957 .is_enabled(),
8958 )
8959 };
8960
8961 #[inline]
8962 fn from_wire(wire: WireInstanceToken) -> Self {
8963 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
8964 }
8965}
8966
8967impl ::fidl_next::IntoNatural for WireInstanceToken {
8968 type Natural = InstanceToken;
8969}
8970
8971#[derive(Debug)]
8973#[repr(C)]
8974pub struct WireInstanceToken {
8975 pub token: ::fidl_next::fuchsia::WireEventPair,
8976}
8977static_assertions::const_assert_eq!(std::mem::size_of::<WireInstanceToken>(), 4);
8978static_assertions::const_assert_eq!(std::mem::align_of::<WireInstanceToken>(), 4);
8979
8980static_assertions::const_assert_eq!(std::mem::offset_of!(WireInstanceToken, token), 0);
8981
8982unsafe impl ::fidl_next::Wire for WireInstanceToken {
8983 type Decoded<'de> = WireInstanceToken;
8984
8985 #[inline]
8986 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8987 ::fidl_next::munge! {
8988 let Self {
8989
8990 token,
8991
8992 } = &mut *out_;
8993 }
8994
8995 ::fidl_next::Wire::zero_padding(token);
8996 }
8997}
8998
8999unsafe impl<___D> ::fidl_next::Decode<___D> for WireInstanceToken
9000where
9001 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9002 ___D: ::fidl_next::fuchsia::HandleDecoder,
9003{
9004 fn decode(
9005 slot_: ::fidl_next::Slot<'_, Self>,
9006 decoder_: &mut ___D,
9007 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9008 ::fidl_next::munge! {
9009 let Self {
9010
9011 mut token,
9012
9013 } = slot_;
9014 }
9015
9016 ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
9017
9018 Ok(())
9019 }
9020}
9021
9022#[doc = " A request for a route.\n"]
9023#[derive(PartialEq, Debug, Default)]
9024pub struct RouteRequest {
9025 pub requesting: ::core::option::Option<crate::InstanceToken>,
9026
9027 pub metadata: ::core::option::Option<crate::DictionaryRef>,
9028}
9029
9030impl RouteRequest {
9031 fn __max_ordinal(&self) -> usize {
9032 if self.metadata.is_some() {
9033 return 2;
9034 }
9035
9036 if self.requesting.is_some() {
9037 return 1;
9038 }
9039
9040 0
9041 }
9042}
9043
9044impl ::fidl_next::Encodable for RouteRequest {
9045 type Encoded = WireRouteRequest<'static>;
9046}
9047
9048unsafe impl<___E> ::fidl_next::Encode<___E> for RouteRequest
9049where
9050 ___E: ::fidl_next::Encoder + ?Sized,
9051 ___E: ::fidl_next::fuchsia::HandleEncoder,
9052{
9053 #[inline]
9054 fn encode(
9055 mut self,
9056 encoder: &mut ___E,
9057 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9058 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9059 ::fidl_next::munge!(let WireRouteRequest { table } = out);
9060
9061 let max_ord = self.__max_ordinal();
9062
9063 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
9064 ::fidl_next::Wire::zero_padding(&mut out);
9065
9066 let mut preallocated =
9067 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
9068
9069 for i in 1..=max_ord {
9070 match i {
9071 2 => {
9072 if let Some(value) = self.metadata.take() {
9073 ::fidl_next::WireEnvelope::encode_value(
9074 value,
9075 preallocated.encoder,
9076 &mut out,
9077 )?;
9078 } else {
9079 ::fidl_next::WireEnvelope::encode_zero(&mut out)
9080 }
9081 }
9082
9083 1 => {
9084 if let Some(value) = self.requesting.take() {
9085 ::fidl_next::WireEnvelope::encode_value(
9086 value,
9087 preallocated.encoder,
9088 &mut out,
9089 )?;
9090 } else {
9091 ::fidl_next::WireEnvelope::encode_zero(&mut out)
9092 }
9093 }
9094
9095 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
9096 }
9097 unsafe {
9098 preallocated.write_next(out.assume_init_ref());
9099 }
9100 }
9101
9102 ::fidl_next::WireTable::encode_len(table, max_ord);
9103
9104 Ok(())
9105 }
9106}
9107
9108impl<'de> ::fidl_next::FromWire<WireRouteRequest<'de>> for RouteRequest {
9109 #[inline]
9110 fn from_wire(wire_: WireRouteRequest<'de>) -> Self {
9111 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
9112
9113 let requesting = wire_.table.get(1);
9114
9115 let metadata = wire_.table.get(2);
9116
9117 Self {
9118 requesting: requesting.map(|envelope| {
9119 ::fidl_next::FromWire::from_wire(unsafe {
9120 envelope.read_unchecked::<crate::WireInstanceToken>()
9121 })
9122 }),
9123
9124 metadata: metadata.map(|envelope| {
9125 ::fidl_next::FromWire::from_wire(unsafe {
9126 envelope.read_unchecked::<crate::WireDictionaryRef>()
9127 })
9128 }),
9129 }
9130 }
9131}
9132
9133impl<'de> ::fidl_next::IntoNatural for WireRouteRequest<'de> {
9134 type Natural = RouteRequest;
9135}
9136
9137#[repr(C)]
9139pub struct WireRouteRequest<'de> {
9140 table: ::fidl_next::WireTable<'de>,
9141}
9142
9143impl<'de> Drop for WireRouteRequest<'de> {
9144 fn drop(&mut self) {
9145 let _ = self
9146 .table
9147 .get(1)
9148 .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireInstanceToken>() });
9149
9150 let _ = self
9151 .table
9152 .get(2)
9153 .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDictionaryRef>() });
9154 }
9155}
9156
9157unsafe impl ::fidl_next::Wire for WireRouteRequest<'static> {
9158 type Decoded<'de> = WireRouteRequest<'de>;
9159
9160 #[inline]
9161 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9162 ::fidl_next::munge!(let Self { table } = out);
9163 ::fidl_next::WireTable::zero_padding(table);
9164 }
9165}
9166
9167unsafe impl<___D> ::fidl_next::Decode<___D> for WireRouteRequest<'static>
9168where
9169 ___D: ::fidl_next::Decoder + ?Sized,
9170 ___D: ::fidl_next::fuchsia::HandleDecoder,
9171{
9172 fn decode(
9173 slot: ::fidl_next::Slot<'_, Self>,
9174 decoder: &mut ___D,
9175 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9176 ::fidl_next::munge!(let Self { table } = slot);
9177
9178 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
9179 match ordinal {
9180 0 => unsafe { ::core::hint::unreachable_unchecked() },
9181
9182 1 => {
9183 ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireInstanceToken>(
9184 slot.as_mut(),
9185 decoder,
9186 )?;
9187
9188 Ok(())
9189 }
9190
9191 2 => {
9192 ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDictionaryRef>(
9193 slot.as_mut(),
9194 decoder,
9195 )?;
9196
9197 Ok(())
9198 }
9199
9200 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
9201 }
9202 })
9203 }
9204}
9205
9206impl<'de> WireRouteRequest<'de> {
9207 pub fn requesting(&self) -> ::core::option::Option<&crate::WireInstanceToken> {
9208 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
9209 }
9210
9211 pub fn metadata(&self) -> ::core::option::Option<&crate::WireDictionaryRef> {
9212 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
9213 }
9214}
9215
9216impl<'de> ::core::fmt::Debug for WireRouteRequest<'de> {
9217 fn fmt(
9218 &self,
9219 f: &mut ::core::fmt::Formatter<'_>,
9220 ) -> ::core::result::Result<(), ::core::fmt::Error> {
9221 f.debug_struct("RouteRequest")
9222 .field("requesting", &self.requesting())
9223 .field("metadata", &self.metadata())
9224 .finish()
9225 }
9226}
9227
9228#[derive(PartialEq, Debug)]
9229pub enum ConnectorRouterRouteResponse {
9230 Connector(crate::Connector),
9231
9232 Unavailable(crate::Unit),
9233}
9234
9235impl ::fidl_next::Encodable for ConnectorRouterRouteResponse {
9236 type Encoded = WireConnectorRouterRouteResponse;
9237}
9238
9239unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectorRouterRouteResponse
9240where
9241 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9242 ___E: ::fidl_next::fuchsia::HandleEncoder,
9243{
9244 #[inline]
9245 fn encode(
9246 self,
9247 encoder: &mut ___E,
9248 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9249 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9250 ::fidl_next::munge!(let WireConnectorRouterRouteResponse { raw, _phantom: _ } = out);
9251
9252 match self {
9253 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
9254 ___E,
9255 crate::Connector,
9256 >(value, 1, encoder, raw)?,
9257
9258 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
9259 ___E,
9260 crate::Unit,
9261 >(value, 2, encoder, raw)?,
9262 }
9263
9264 Ok(())
9265 }
9266}
9267
9268impl ::fidl_next::EncodableOption for ConnectorRouterRouteResponse {
9269 type EncodedOption = WireOptionalConnectorRouterRouteResponse;
9270}
9271
9272unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConnectorRouterRouteResponse
9273where
9274 ___E: ?Sized,
9275 ConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
9276{
9277 #[inline]
9278 fn encode_option(
9279 this: ::core::option::Option<Self>,
9280 encoder: &mut ___E,
9281 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
9282 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9283 ::fidl_next::munge!(let WireOptionalConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
9284
9285 if let Some(inner) = this {
9286 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
9287 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
9288 } else {
9289 ::fidl_next::RawWireUnion::encode_absent(raw);
9290 }
9291
9292 Ok(())
9293 }
9294}
9295
9296impl ::fidl_next::FromWire<WireConnectorRouterRouteResponse> for ConnectorRouterRouteResponse {
9297 #[inline]
9298 fn from_wire(wire: WireConnectorRouterRouteResponse) -> Self {
9299 let wire = ::core::mem::ManuallyDrop::new(wire);
9300 match wire.raw.ordinal() {
9301 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
9302 wire.raw.get().read_unchecked::<crate::WireConnector>()
9303 })),
9304
9305 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
9306 wire.raw.get().read_unchecked::<crate::WireUnit>()
9307 })),
9308
9309 _ => unsafe { ::core::hint::unreachable_unchecked() },
9310 }
9311 }
9312}
9313
9314impl ::fidl_next::IntoNatural for WireConnectorRouterRouteResponse {
9315 type Natural = ConnectorRouterRouteResponse;
9316}
9317
9318impl ::fidl_next::FromWireOption<WireOptionalConnectorRouterRouteResponse>
9319 for ConnectorRouterRouteResponse
9320{
9321 #[inline]
9322 fn from_wire_option(
9323 wire: WireOptionalConnectorRouterRouteResponse,
9324 ) -> ::core::option::Option<Self> {
9325 if let Some(inner) = wire.into_option() {
9326 Some(::fidl_next::FromWire::from_wire(inner))
9327 } else {
9328 None
9329 }
9330 }
9331}
9332
9333impl ::fidl_next::IntoNatural for WireOptionalConnectorRouterRouteResponse {
9334 type Natural = ::core::option::Option<ConnectorRouterRouteResponse>;
9335}
9336
9337impl ::fidl_next::FromWireOption<WireOptionalConnectorRouterRouteResponse>
9338 for Box<ConnectorRouterRouteResponse>
9339{
9340 #[inline]
9341 fn from_wire_option(
9342 wire: WireOptionalConnectorRouterRouteResponse,
9343 ) -> ::core::option::Option<Self> {
9344 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
9345 WireOptionalConnectorRouterRouteResponse,
9346 >>::from_wire_option(wire)
9347 .map(Box::new)
9348 }
9349}
9350
9351#[repr(transparent)]
9353pub struct WireConnectorRouterRouteResponse {
9354 raw: ::fidl_next::RawWireUnion,
9355 _phantom: ::core::marker::PhantomData<()>,
9356}
9357
9358impl Drop for WireConnectorRouterRouteResponse {
9359 fn drop(&mut self) {
9360 match self.raw.ordinal() {
9361 1 => {
9362 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireConnector>() };
9363 }
9364
9365 2 => {
9366 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
9367 }
9368
9369 _ => unsafe { ::core::hint::unreachable_unchecked() },
9370 }
9371 }
9372}
9373
9374unsafe impl ::fidl_next::Wire for WireConnectorRouterRouteResponse {
9375 type Decoded<'de> = WireConnectorRouterRouteResponse;
9376
9377 #[inline]
9378 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9379 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9380 ::fidl_next::RawWireUnion::zero_padding(raw);
9381 }
9382}
9383
9384pub mod connector_router_route_response {
9385 pub enum Ref<'de> {
9386 Connector(&'de crate::WireConnector),
9387
9388 Unavailable(&'de crate::WireUnit),
9389 }
9390}
9391
9392impl WireConnectorRouterRouteResponse {
9393 pub fn as_ref(&self) -> crate::connector_router_route_response::Ref<'_> {
9394 match self.raw.ordinal() {
9395 1 => crate::connector_router_route_response::Ref::Connector(unsafe {
9396 self.raw.get().deref_unchecked::<crate::WireConnector>()
9397 }),
9398
9399 2 => crate::connector_router_route_response::Ref::Unavailable(unsafe {
9400 self.raw.get().deref_unchecked::<crate::WireUnit>()
9401 }),
9402
9403 _ => unsafe { ::core::hint::unreachable_unchecked() },
9404 }
9405 }
9406}
9407
9408unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnectorRouterRouteResponse
9409where
9410 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9411 ___D: ::fidl_next::fuchsia::HandleDecoder,
9412{
9413 fn decode(
9414 mut slot: ::fidl_next::Slot<'_, Self>,
9415 decoder: &mut ___D,
9416 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9417 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9418 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
9419 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireConnector>(
9420 raw, decoder,
9421 )?,
9422
9423 2 => {
9424 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
9425 }
9426
9427 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
9428 }
9429
9430 Ok(())
9431 }
9432}
9433
9434impl ::core::fmt::Debug for WireConnectorRouterRouteResponse {
9435 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9436 match self.raw.ordinal() {
9437 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireConnector>().fmt(f) },
9438 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
9439 _ => unsafe { ::core::hint::unreachable_unchecked() },
9440 }
9441 }
9442}
9443
9444#[repr(transparent)]
9445pub struct WireOptionalConnectorRouterRouteResponse {
9446 raw: ::fidl_next::RawWireUnion,
9447 _phantom: ::core::marker::PhantomData<()>,
9448}
9449
9450unsafe impl ::fidl_next::Wire for WireOptionalConnectorRouterRouteResponse {
9451 type Decoded<'de> = WireOptionalConnectorRouterRouteResponse;
9452
9453 #[inline]
9454 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9455 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9456 ::fidl_next::RawWireUnion::zero_padding(raw);
9457 }
9458}
9459
9460impl WireOptionalConnectorRouterRouteResponse {
9461 pub fn is_some(&self) -> bool {
9462 self.raw.is_some()
9463 }
9464
9465 pub fn is_none(&self) -> bool {
9466 self.raw.is_none()
9467 }
9468
9469 pub fn as_ref(&self) -> ::core::option::Option<&WireConnectorRouterRouteResponse> {
9470 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
9471 }
9472
9473 pub fn into_option(self) -> ::core::option::Option<WireConnectorRouterRouteResponse> {
9474 if self.is_some() {
9475 Some(WireConnectorRouterRouteResponse {
9476 raw: self.raw,
9477 _phantom: ::core::marker::PhantomData,
9478 })
9479 } else {
9480 None
9481 }
9482 }
9483}
9484
9485unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConnectorRouterRouteResponse
9486where
9487 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9488 ___D: ::fidl_next::fuchsia::HandleDecoder,
9489{
9490 fn decode(
9491 mut slot: ::fidl_next::Slot<'_, Self>,
9492 decoder: &mut ___D,
9493 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9494 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9495 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
9496 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireConnector>(
9497 raw, decoder,
9498 )?,
9499
9500 2 => {
9501 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
9502 }
9503
9504 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
9505 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
9506 }
9507
9508 Ok(())
9509 }
9510}
9511
9512impl ::core::fmt::Debug for WireOptionalConnectorRouterRouteResponse {
9513 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9514 self.as_ref().fmt(f)
9515 }
9516}
9517
9518#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9519#[repr(u32)]
9520pub enum RouterError {
9521 NotFound = 1,
9522 InvalidArgs = 2,
9523 NotSupported = 3,
9524 Internal = 4,
9525 UnknownOrdinal_(u32) = 5,
9526}
9527
9528impl ::fidl_next::Encodable for RouterError {
9529 type Encoded = WireRouterError;
9530}
9531impl ::std::convert::From<u32> for RouterError {
9532 fn from(value: u32) -> Self {
9533 match value {
9534 1 => Self::NotFound,
9535 2 => Self::InvalidArgs,
9536 3 => Self::NotSupported,
9537 4 => Self::Internal,
9538
9539 _ => Self::UnknownOrdinal_(value),
9540 }
9541 }
9542}
9543
9544unsafe impl<___E> ::fidl_next::Encode<___E> for RouterError
9545where
9546 ___E: ?Sized,
9547{
9548 #[inline]
9549 fn encode(
9550 self,
9551 encoder: &mut ___E,
9552 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9554 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
9555 }
9556}
9557
9558unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RouterError
9559where
9560 ___E: ?Sized,
9561{
9562 #[inline]
9563 fn encode_ref(
9564 &self,
9565 encoder: &mut ___E,
9566 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9567 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9568 ::fidl_next::munge!(let WireRouterError { value } = out);
9569 let _ = value.write(::fidl_next::WireU32::from(match *self {
9570 Self::NotFound => 1,
9571
9572 Self::InvalidArgs => 2,
9573
9574 Self::NotSupported => 3,
9575
9576 Self::Internal => 4,
9577
9578 Self::UnknownOrdinal_(value) => value,
9579 }));
9580
9581 Ok(())
9582 }
9583}
9584
9585impl ::core::convert::From<WireRouterError> for RouterError {
9586 fn from(wire: WireRouterError) -> Self {
9587 match u32::from(wire.value) {
9588 1 => Self::NotFound,
9589
9590 2 => Self::InvalidArgs,
9591
9592 3 => Self::NotSupported,
9593
9594 4 => Self::Internal,
9595
9596 value => Self::UnknownOrdinal_(value),
9597 }
9598 }
9599}
9600
9601impl ::fidl_next::FromWire<WireRouterError> for RouterError {
9602 #[inline]
9603 fn from_wire(wire: WireRouterError) -> Self {
9604 Self::from(wire)
9605 }
9606}
9607
9608impl ::fidl_next::IntoNatural for WireRouterError {
9609 type Natural = RouterError;
9610}
9611
9612impl ::fidl_next::FromWireRef<WireRouterError> for RouterError {
9613 #[inline]
9614 fn from_wire_ref(wire: &WireRouterError) -> Self {
9615 Self::from(*wire)
9616 }
9617}
9618
9619#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9621#[repr(transparent)]
9622pub struct WireRouterError {
9623 value: ::fidl_next::WireU32,
9624}
9625
9626unsafe impl ::fidl_next::Wire for WireRouterError {
9627 type Decoded<'de> = Self;
9628
9629 #[inline]
9630 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9631 }
9633}
9634
9635impl WireRouterError {
9636 pub const NOT_FOUND: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(1) };
9637
9638 pub const INVALID_ARGS: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(2) };
9639
9640 pub const NOT_SUPPORTED: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(3) };
9641
9642 pub const INTERNAL: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(4) };
9643}
9644
9645unsafe impl<___D> ::fidl_next::Decode<___D> for WireRouterError
9646where
9647 ___D: ?Sized,
9648{
9649 fn decode(
9650 slot: ::fidl_next::Slot<'_, Self>,
9651 _: &mut ___D,
9652 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9653 Ok(())
9654 }
9655}
9656
9657impl ::core::convert::From<RouterError> for WireRouterError {
9658 fn from(natural: RouterError) -> Self {
9659 match natural {
9660 RouterError::NotFound => WireRouterError::NOT_FOUND,
9661
9662 RouterError::InvalidArgs => WireRouterError::INVALID_ARGS,
9663
9664 RouterError::NotSupported => WireRouterError::NOT_SUPPORTED,
9665
9666 RouterError::Internal => WireRouterError::INTERNAL,
9667
9668 RouterError::UnknownOrdinal_(value) => {
9669 WireRouterError { value: ::fidl_next::WireU32::from(value) }
9670 }
9671 }
9672 }
9673}
9674
9675#[derive(PartialEq, Debug)]
9677pub struct ConnectorRouter;
9678
9679impl ::fidl_next::Discoverable for ConnectorRouter {
9680 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
9681}
9682
9683pub mod connector_router {
9684 pub mod prelude {
9685 pub use crate::{
9686 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
9687 connector_router,
9688 };
9689
9690 pub use crate::ConnectorRouterRouteResponse;
9691
9692 pub use crate::RouteRequest;
9693
9694 pub use crate::RouterError;
9695 }
9696
9697 pub struct Route;
9698
9699 impl ::fidl_next::Method for Route {
9700 const ORDINAL: u64 = 8420527046218942310;
9701
9702 type Protocol = crate::ConnectorRouter;
9703
9704 type Request = crate::WireRouteRequest<'static>;
9705
9706 type Response = ::fidl_next::WireFlexibleResult<
9707 'static,
9708 crate::WireConnectorRouterRouteResponse,
9709 crate::WireRouterError,
9710 >;
9711 }
9712
9713 mod ___detail {
9714
9715 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ConnectorRouter
9716 where
9717 ___T: ::fidl_next::Transport,
9718 {
9719 type Client = ConnectorRouterClient<___T>;
9720 type Server = ConnectorRouterServer<___T>;
9721 }
9722
9723 #[repr(transparent)]
9725 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
9726 #[allow(dead_code)]
9727 client: ::fidl_next::protocol::Client<___T>,
9728 }
9729
9730 impl<___T> ConnectorRouterClient<___T>
9731 where
9732 ___T: ::fidl_next::Transport,
9733 {
9734 pub fn route_with<___R>(
9735 &self,
9736 request: ___R,
9737 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
9738 where
9739 ___R: ::fidl_next::Encode<
9740 <___T as ::fidl_next::Transport>::SendBuffer,
9741 Encoded = crate::WireRouteRequest<'static>,
9742 >,
9743 {
9744 ::fidl_next::TwoWayFuture::from_untyped(
9745 self.client.send_two_way(8420527046218942310, request),
9746 )
9747 }
9748 }
9749
9750 #[repr(transparent)]
9752 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
9753 server: ::fidl_next::protocol::Server<___T>,
9754 }
9755
9756 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
9757 }
9758}
9759
9760pub trait ConnectorRouterClientHandler<
9764 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
9765 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9766>
9767{
9768 fn on_unknown_interaction(
9769 &mut self,
9770 ordinal: u64,
9771 ) -> impl ::core::future::Future<
9772 Output = ::core::result::Result<
9773 (),
9774 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9775 >,
9776 > + ::core::marker::Send {
9777 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
9778 }
9779}
9780
9781impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
9782where
9783 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
9784 ___T: ::fidl_next::Transport,
9785 <connector_router::Route as ::fidl_next::Method>::Response:
9786 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9787{
9788 async fn on_event(
9789 handler: &mut ___H,
9790 ordinal: u64,
9791 buffer: ___T::RecvBuffer,
9792 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9793 match ordinal {
9794 ordinal => handler.on_unknown_interaction(ordinal).await,
9795 }
9796 }
9797}
9798
9799pub trait ConnectorRouterServerHandler<
9803 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
9804 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9805>
9806{
9807 fn route(
9808 &mut self,
9809
9810 request: ::fidl_next::Request<connector_router::Route, ___T>,
9811
9812 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
9813 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9814
9815 fn on_unknown_interaction(
9816 &mut self,
9817 ordinal: u64,
9818 ) -> impl ::core::future::Future<
9819 Output = ::core::result::Result<
9820 (),
9821 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9822 >,
9823 > + ::core::marker::Send {
9824 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
9825 }
9826}
9827
9828impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
9829where
9830 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
9831 ___T: ::fidl_next::Transport,
9832 <connector_router::Route as ::fidl_next::Method>::Request:
9833 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9834{
9835 async fn on_one_way(
9836 handler: &mut ___H,
9837 ordinal: u64,
9838 buffer: ___T::RecvBuffer,
9839 ) -> ::core::result::Result<
9840 (),
9841 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9842 > {
9843 match ordinal {
9844 ordinal => handler.on_unknown_interaction(ordinal).await,
9845 }
9846 }
9847
9848 async fn on_two_way(
9849 handler: &mut ___H,
9850 ordinal: u64,
9851 buffer: ___T::RecvBuffer,
9852 responder: ::fidl_next::protocol::Responder<___T>,
9853 ) -> ::core::result::Result<
9854 (),
9855 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9856 > {
9857 match ordinal {
9858 8420527046218942310 => {
9859 let responder = ::fidl_next::Responder::from_untyped(responder);
9860
9861 match ::fidl_next::DecoderExt::decode(buffer) {
9862 Ok(decoded) => {
9863 handler.route(decoded, responder).await;
9864 Ok(())
9865 }
9866 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9867 ordinal: 8420527046218942310,
9868 error,
9869 }),
9870 }
9871 }
9872
9873 ordinal => handler.on_unknown_interaction(ordinal).await,
9874 }
9875 }
9876}
9877
9878#[derive(PartialEq, Debug)]
9879pub enum DataRouterRouteResponse {
9880 Data(crate::Data),
9881
9882 Unavailable(crate::Unit),
9883}
9884
9885impl ::fidl_next::Encodable for DataRouterRouteResponse {
9886 type Encoded = WireDataRouterRouteResponse<'static>;
9887}
9888
9889unsafe impl<___E> ::fidl_next::Encode<___E> for DataRouterRouteResponse
9890where
9891 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9892 ___E: ::fidl_next::Encoder,
9893 ___E: ::fidl_next::fuchsia::HandleEncoder,
9894{
9895 #[inline]
9896 fn encode(
9897 self,
9898 encoder: &mut ___E,
9899 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9900 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9901 ::fidl_next::munge!(let WireDataRouterRouteResponse { raw, _phantom: _ } = out);
9902
9903 match self {
9904 Self::Data(value) => {
9905 ::fidl_next::RawWireUnion::encode_as::<___E, crate::Data>(value, 1, encoder, raw)?
9906 }
9907
9908 Self::Unavailable(value) => {
9909 ::fidl_next::RawWireUnion::encode_as::<___E, crate::Unit>(value, 2, encoder, raw)?
9910 }
9911 }
9912
9913 Ok(())
9914 }
9915}
9916
9917impl ::fidl_next::EncodableOption for DataRouterRouteResponse {
9918 type EncodedOption = WireOptionalDataRouterRouteResponse<'static>;
9919}
9920
9921unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DataRouterRouteResponse
9922where
9923 ___E: ?Sized,
9924 DataRouterRouteResponse: ::fidl_next::Encode<___E>,
9925{
9926 #[inline]
9927 fn encode_option(
9928 this: ::core::option::Option<Self>,
9929 encoder: &mut ___E,
9930 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
9931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9932 ::fidl_next::munge!(let WireOptionalDataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
9933
9934 if let Some(inner) = this {
9935 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
9936 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
9937 } else {
9938 ::fidl_next::RawWireUnion::encode_absent(raw);
9939 }
9940
9941 Ok(())
9942 }
9943}
9944
9945impl<'de> ::fidl_next::FromWire<WireDataRouterRouteResponse<'de>> for DataRouterRouteResponse {
9946 #[inline]
9947 fn from_wire(wire: WireDataRouterRouteResponse<'de>) -> Self {
9948 let wire = ::core::mem::ManuallyDrop::new(wire);
9949 match wire.raw.ordinal() {
9950 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
9951 wire.raw.get().read_unchecked::<crate::WireData<'de>>()
9952 })),
9953
9954 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
9955 wire.raw.get().read_unchecked::<crate::WireUnit>()
9956 })),
9957
9958 _ => unsafe { ::core::hint::unreachable_unchecked() },
9959 }
9960 }
9961}
9962
9963impl<'de> ::fidl_next::IntoNatural for WireDataRouterRouteResponse<'de> {
9964 type Natural = DataRouterRouteResponse;
9965}
9966
9967impl<'de> ::fidl_next::FromWireOption<WireOptionalDataRouterRouteResponse<'de>>
9968 for DataRouterRouteResponse
9969{
9970 #[inline]
9971 fn from_wire_option(
9972 wire: WireOptionalDataRouterRouteResponse<'de>,
9973 ) -> ::core::option::Option<Self> {
9974 if let Some(inner) = wire.into_option() {
9975 Some(::fidl_next::FromWire::from_wire(inner))
9976 } else {
9977 None
9978 }
9979 }
9980}
9981
9982impl<'de> ::fidl_next::IntoNatural for WireOptionalDataRouterRouteResponse<'de> {
9983 type Natural = ::core::option::Option<DataRouterRouteResponse>;
9984}
9985
9986impl<'de> ::fidl_next::FromWireOption<WireOptionalDataRouterRouteResponse<'de>>
9987 for Box<DataRouterRouteResponse>
9988{
9989 #[inline]
9990 fn from_wire_option(
9991 wire: WireOptionalDataRouterRouteResponse<'de>,
9992 ) -> ::core::option::Option<Self> {
9993 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
9994 WireOptionalDataRouterRouteResponse<'de>,
9995 >>::from_wire_option(wire)
9996 .map(Box::new)
9997 }
9998}
9999
10000#[repr(transparent)]
10002pub struct WireDataRouterRouteResponse<'de> {
10003 raw: ::fidl_next::RawWireUnion,
10004 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
10005}
10006
10007impl<'de> Drop for WireDataRouterRouteResponse<'de> {
10008 fn drop(&mut self) {
10009 match self.raw.ordinal() {
10010 1 => {
10011 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireData<'de>>() };
10012 }
10013
10014 2 => {
10015 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
10016 }
10017
10018 _ => unsafe { ::core::hint::unreachable_unchecked() },
10019 }
10020 }
10021}
10022
10023unsafe impl ::fidl_next::Wire for WireDataRouterRouteResponse<'static> {
10024 type Decoded<'de> = WireDataRouterRouteResponse<'de>;
10025
10026 #[inline]
10027 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10028 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
10029 ::fidl_next::RawWireUnion::zero_padding(raw);
10030 }
10031}
10032
10033pub mod data_router_route_response {
10034 pub enum Ref<'de> {
10035 Data(&'de crate::WireData<'de>),
10036
10037 Unavailable(&'de crate::WireUnit),
10038 }
10039}
10040
10041impl<'de> WireDataRouterRouteResponse<'de> {
10042 pub fn as_ref(&self) -> crate::data_router_route_response::Ref<'_> {
10043 match self.raw.ordinal() {
10044 1 => crate::data_router_route_response::Ref::Data(unsafe {
10045 self.raw.get().deref_unchecked::<crate::WireData<'_>>()
10046 }),
10047
10048 2 => crate::data_router_route_response::Ref::Unavailable(unsafe {
10049 self.raw.get().deref_unchecked::<crate::WireUnit>()
10050 }),
10051
10052 _ => unsafe { ::core::hint::unreachable_unchecked() },
10053 }
10054 }
10055}
10056
10057unsafe impl<___D> ::fidl_next::Decode<___D> for WireDataRouterRouteResponse<'static>
10058where
10059 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10060 ___D: ::fidl_next::Decoder,
10061 ___D: ::fidl_next::fuchsia::HandleDecoder,
10062{
10063 fn decode(
10064 mut slot: ::fidl_next::Slot<'_, Self>,
10065 decoder: &mut ___D,
10066 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10067 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
10068 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
10069 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
10070 raw, decoder,
10071 )?,
10072
10073 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
10074
10075 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
10076 }
10077
10078 Ok(())
10079 }
10080}
10081
10082impl<'de> ::core::fmt::Debug for WireDataRouterRouteResponse<'de> {
10083 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10084 match self.raw.ordinal() {
10085 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireData<'_>>().fmt(f) },
10086 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
10087 _ => unsafe { ::core::hint::unreachable_unchecked() },
10088 }
10089 }
10090}
10091
10092#[repr(transparent)]
10093pub struct WireOptionalDataRouterRouteResponse<'de> {
10094 raw: ::fidl_next::RawWireUnion,
10095 _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
10096}
10097
10098unsafe impl ::fidl_next::Wire for WireOptionalDataRouterRouteResponse<'static> {
10099 type Decoded<'de> = WireOptionalDataRouterRouteResponse<'de>;
10100
10101 #[inline]
10102 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10103 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
10104 ::fidl_next::RawWireUnion::zero_padding(raw);
10105 }
10106}
10107
10108impl<'de> WireOptionalDataRouterRouteResponse<'de> {
10109 pub fn is_some(&self) -> bool {
10110 self.raw.is_some()
10111 }
10112
10113 pub fn is_none(&self) -> bool {
10114 self.raw.is_none()
10115 }
10116
10117 pub fn as_ref(&self) -> ::core::option::Option<&WireDataRouterRouteResponse<'de>> {
10118 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
10119 }
10120
10121 pub fn into_option(self) -> ::core::option::Option<WireDataRouterRouteResponse<'de>> {
10122 if self.is_some() {
10123 Some(WireDataRouterRouteResponse {
10124 raw: self.raw,
10125 _phantom: ::core::marker::PhantomData,
10126 })
10127 } else {
10128 None
10129 }
10130 }
10131}
10132
10133unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDataRouterRouteResponse<'static>
10134where
10135 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10136 ___D: ::fidl_next::Decoder,
10137 ___D: ::fidl_next::fuchsia::HandleDecoder,
10138{
10139 fn decode(
10140 mut slot: ::fidl_next::Slot<'_, Self>,
10141 decoder: &mut ___D,
10142 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10143 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
10144 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
10145 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
10146 raw, decoder,
10147 )?,
10148
10149 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
10150
10151 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
10152 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
10153 }
10154
10155 Ok(())
10156 }
10157}
10158
10159impl<'de> ::core::fmt::Debug for WireOptionalDataRouterRouteResponse<'de> {
10160 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10161 self.as_ref().fmt(f)
10162 }
10163}
10164
10165#[derive(PartialEq, Debug)]
10167pub struct DataRouter;
10168
10169impl ::fidl_next::Discoverable for DataRouter {
10170 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
10171}
10172
10173pub mod data_router {
10174 pub mod prelude {
10175 pub use crate::{
10176 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
10177 };
10178
10179 pub use crate::DataRouterRouteResponse;
10180
10181 pub use crate::RouteRequest;
10182
10183 pub use crate::RouterError;
10184 }
10185
10186 pub struct Route;
10187
10188 impl ::fidl_next::Method for Route {
10189 const ORDINAL: u64 = 3352890635970754564;
10190
10191 type Protocol = crate::DataRouter;
10192
10193 type Request = crate::WireRouteRequest<'static>;
10194
10195 type Response = ::fidl_next::WireFlexibleResult<
10196 'static,
10197 crate::WireDataRouterRouteResponse<'static>,
10198 crate::WireRouterError,
10199 >;
10200 }
10201
10202 mod ___detail {
10203
10204 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DataRouter
10205 where
10206 ___T: ::fidl_next::Transport,
10207 {
10208 type Client = DataRouterClient<___T>;
10209 type Server = DataRouterServer<___T>;
10210 }
10211
10212 #[repr(transparent)]
10214 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
10215 #[allow(dead_code)]
10216 client: ::fidl_next::protocol::Client<___T>,
10217 }
10218
10219 impl<___T> DataRouterClient<___T>
10220 where
10221 ___T: ::fidl_next::Transport,
10222 {
10223 pub fn route_with<___R>(
10224 &self,
10225 request: ___R,
10226 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10227 where
10228 ___R: ::fidl_next::Encode<
10229 <___T as ::fidl_next::Transport>::SendBuffer,
10230 Encoded = crate::WireRouteRequest<'static>,
10231 >,
10232 {
10233 ::fidl_next::TwoWayFuture::from_untyped(
10234 self.client.send_two_way(3352890635970754564, request),
10235 )
10236 }
10237 }
10238
10239 #[repr(transparent)]
10241 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
10242 server: ::fidl_next::protocol::Server<___T>,
10243 }
10244
10245 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
10246 }
10247}
10248
10249pub trait DataRouterClientHandler<
10253 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10254 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10255>
10256{
10257 fn on_unknown_interaction(
10258 &mut self,
10259 ordinal: u64,
10260 ) -> impl ::core::future::Future<
10261 Output = ::core::result::Result<
10262 (),
10263 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10264 >,
10265 > + ::core::marker::Send {
10266 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10267 }
10268}
10269
10270impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
10271where
10272 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
10273 ___T: ::fidl_next::Transport,
10274 <data_router::Route as ::fidl_next::Method>::Response:
10275 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10276{
10277 async fn on_event(
10278 handler: &mut ___H,
10279 ordinal: u64,
10280 buffer: ___T::RecvBuffer,
10281 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10282 match ordinal {
10283 ordinal => handler.on_unknown_interaction(ordinal).await,
10284 }
10285 }
10286}
10287
10288pub trait DataRouterServerHandler<
10292 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10293 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10294>
10295{
10296 fn route(
10297 &mut self,
10298
10299 request: ::fidl_next::Request<data_router::Route, ___T>,
10300
10301 responder: ::fidl_next::Responder<data_router::Route, ___T>,
10302 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10303
10304 fn on_unknown_interaction(
10305 &mut self,
10306 ordinal: u64,
10307 ) -> impl ::core::future::Future<
10308 Output = ::core::result::Result<
10309 (),
10310 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10311 >,
10312 > + ::core::marker::Send {
10313 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10314 }
10315}
10316
10317impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
10318where
10319 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
10320 ___T: ::fidl_next::Transport,
10321 <data_router::Route as ::fidl_next::Method>::Request:
10322 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10323{
10324 async fn on_one_way(
10325 handler: &mut ___H,
10326 ordinal: u64,
10327 buffer: ___T::RecvBuffer,
10328 ) -> ::core::result::Result<
10329 (),
10330 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10331 > {
10332 match ordinal {
10333 ordinal => handler.on_unknown_interaction(ordinal).await,
10334 }
10335 }
10336
10337 async fn on_two_way(
10338 handler: &mut ___H,
10339 ordinal: u64,
10340 buffer: ___T::RecvBuffer,
10341 responder: ::fidl_next::protocol::Responder<___T>,
10342 ) -> ::core::result::Result<
10343 (),
10344 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10345 > {
10346 match ordinal {
10347 3352890635970754564 => {
10348 let responder = ::fidl_next::Responder::from_untyped(responder);
10349
10350 match ::fidl_next::DecoderExt::decode(buffer) {
10351 Ok(decoded) => {
10352 handler.route(decoded, responder).await;
10353 Ok(())
10354 }
10355 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10356 ordinal: 3352890635970754564,
10357 error,
10358 }),
10359 }
10360 }
10361
10362 ordinal => handler.on_unknown_interaction(ordinal).await,
10363 }
10364 }
10365}
10366
10367#[derive(PartialEq, Debug)]
10369pub struct Dictionary;
10370
10371impl ::fidl_next::Discoverable for Dictionary {
10372 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
10373}
10374
10375pub mod dictionary {
10376 pub mod prelude {
10377 pub use crate::{Dictionary, DictionaryClientHandler, DictionaryServerHandler, dictionary};
10378 }
10379
10380 mod ___detail {
10381
10382 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Dictionary
10383 where
10384 ___T: ::fidl_next::Transport,
10385 {
10386 type Client = DictionaryClient<___T>;
10387 type Server = DictionaryServer<___T>;
10388 }
10389
10390 #[repr(transparent)]
10392 pub struct DictionaryClient<___T: ::fidl_next::Transport> {
10393 #[allow(dead_code)]
10394 client: ::fidl_next::protocol::Client<___T>,
10395 }
10396
10397 impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
10398
10399 #[repr(transparent)]
10401 pub struct DictionaryServer<___T: ::fidl_next::Transport> {
10402 server: ::fidl_next::protocol::Server<___T>,
10403 }
10404
10405 impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
10406 }
10407}
10408
10409pub trait DictionaryClientHandler<
10413 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10414 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10415>
10416{
10417 fn on_unknown_interaction(
10418 &mut self,
10419 ordinal: u64,
10420 ) -> impl ::core::future::Future<
10421 Output = ::core::result::Result<
10422 (),
10423 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10424 >,
10425 > + ::core::marker::Send {
10426 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10427 }
10428}
10429
10430impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
10431where
10432 ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
10433 ___T: ::fidl_next::Transport,
10434{
10435 async fn on_event(
10436 handler: &mut ___H,
10437 ordinal: u64,
10438 buffer: ___T::RecvBuffer,
10439 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10440 match ordinal {
10441 ordinal => handler.on_unknown_interaction(ordinal).await,
10442 }
10443 }
10444}
10445
10446pub trait DictionaryServerHandler<
10450 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10451 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10452>
10453{
10454 fn on_unknown_interaction(
10455 &mut self,
10456 ordinal: u64,
10457 ) -> impl ::core::future::Future<
10458 Output = ::core::result::Result<
10459 (),
10460 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10461 >,
10462 > + ::core::marker::Send {
10463 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10464 }
10465}
10466
10467impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
10468where
10469 ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
10470 ___T: ::fidl_next::Transport,
10471{
10472 async fn on_one_way(
10473 handler: &mut ___H,
10474 ordinal: u64,
10475 buffer: ___T::RecvBuffer,
10476 ) -> ::core::result::Result<
10477 (),
10478 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10479 > {
10480 match ordinal {
10481 ordinal => handler.on_unknown_interaction(ordinal).await,
10482 }
10483 }
10484
10485 async fn on_two_way(
10486 handler: &mut ___H,
10487 ordinal: u64,
10488 buffer: ___T::RecvBuffer,
10489 responder: ::fidl_next::protocol::Responder<___T>,
10490 ) -> ::core::result::Result<
10491 (),
10492 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10493 > {
10494 match ordinal {
10495 ordinal => handler.on_unknown_interaction(ordinal).await,
10496 }
10497 }
10498}
10499
10500#[derive(PartialEq, Clone, Debug)]
10501pub struct DictionaryDrainIteratorGetNextRequest {
10502 pub start_id: u64,
10503
10504 pub limit: u32,
10505}
10506
10507impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest {
10508 type Encoded = WireDictionaryDrainIteratorGetNextRequest;
10509}
10510
10511unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextRequest
10512where
10513 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10514{
10515 #[inline]
10516 fn encode(
10517 self,
10518 encoder_: &mut ___E,
10519 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10521 ::fidl_next::munge! {
10522 let Self::Encoded {
10523 start_id,
10524 limit,
10525
10526 } = out_;
10527 }
10528
10529 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
10530
10531 ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
10532
10533 Ok(())
10534 }
10535}
10536
10537unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryDrainIteratorGetNextRequest
10538where
10539 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10540{
10541 #[inline]
10542 fn encode_ref(
10543 &self,
10544 encoder_: &mut ___E,
10545 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10546 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10547 ::fidl_next::munge! {
10548 let Self::Encoded {
10549
10550 start_id,
10551 limit,
10552
10553 } = out_;
10554 }
10555
10556 ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id)?;
10557
10558 ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit)?;
10559
10560 Ok(())
10561 }
10562}
10563
10564impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextRequest {
10565 type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryDrainIteratorGetNextRequest>;
10566}
10567
10568unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextRequest
10569where
10570 ___E: ::fidl_next::Encoder + ?Sized,
10571 DictionaryDrainIteratorGetNextRequest: ::fidl_next::Encode<___E>,
10572{
10573 #[inline]
10574 fn encode_option(
10575 this: ::core::option::Option<Self>,
10576 encoder: &mut ___E,
10577 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10579 if let Some(inner) = this {
10580 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10581 ::fidl_next::WireBox::encode_present(out);
10582 } else {
10583 ::fidl_next::WireBox::encode_absent(out);
10584 }
10585
10586 Ok(())
10587 }
10588}
10589
10590unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryDrainIteratorGetNextRequest
10591where
10592 ___E: ::fidl_next::Encoder + ?Sized,
10593 DictionaryDrainIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
10594{
10595 #[inline]
10596 fn encode_option_ref(
10597 this: ::core::option::Option<&Self>,
10598 encoder: &mut ___E,
10599 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10600 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10601 if let Some(inner) = this {
10602 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10603 ::fidl_next::WireBox::encode_present(out);
10604 } else {
10605 ::fidl_next::WireBox::encode_absent(out);
10606 }
10607
10608 Ok(())
10609 }
10610}
10611
10612impl ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextRequest>
10613 for DictionaryDrainIteratorGetNextRequest
10614{
10615 #[inline]
10616 fn from_wire(wire: WireDictionaryDrainIteratorGetNextRequest) -> Self {
10617 Self {
10618 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
10619
10620 limit: ::fidl_next::FromWire::from_wire(wire.limit),
10621 }
10622 }
10623}
10624
10625impl ::fidl_next::IntoNatural for WireDictionaryDrainIteratorGetNextRequest {
10626 type Natural = DictionaryDrainIteratorGetNextRequest;
10627}
10628
10629impl ::fidl_next::FromWireRef<WireDictionaryDrainIteratorGetNextRequest>
10630 for DictionaryDrainIteratorGetNextRequest
10631{
10632 #[inline]
10633 fn from_wire_ref(wire: &WireDictionaryDrainIteratorGetNextRequest) -> Self {
10634 Self {
10635 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
10636
10637 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
10638 }
10639 }
10640}
10641
10642#[derive(Clone, Debug)]
10644#[repr(C)]
10645pub struct WireDictionaryDrainIteratorGetNextRequest {
10646 pub start_id: ::fidl_next::WireU64,
10647
10648 pub limit: ::fidl_next::WireU32,
10649}
10650static_assertions::const_assert_eq!(
10651 std::mem::size_of::<WireDictionaryDrainIteratorGetNextRequest>(),
10652 16
10653);
10654static_assertions::const_assert_eq!(
10655 std::mem::align_of::<WireDictionaryDrainIteratorGetNextRequest>(),
10656 8
10657);
10658
10659static_assertions::const_assert_eq!(
10660 std::mem::offset_of!(WireDictionaryDrainIteratorGetNextRequest, start_id),
10661 0
10662);
10663
10664static_assertions::const_assert_eq!(
10665 std::mem::offset_of!(WireDictionaryDrainIteratorGetNextRequest, limit),
10666 8
10667);
10668
10669unsafe impl ::fidl_next::Wire for WireDictionaryDrainIteratorGetNextRequest {
10670 type Decoded<'de> = WireDictionaryDrainIteratorGetNextRequest;
10671
10672 #[inline]
10673 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10674 ::fidl_next::munge! {
10675 let Self {
10676
10677 start_id,
10678 limit,
10679
10680 } = &mut *out_;
10681 }
10682
10683 ::fidl_next::Wire::zero_padding(start_id);
10684
10685 ::fidl_next::Wire::zero_padding(limit);
10686
10687 unsafe {
10688 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10689 }
10690 }
10691}
10692
10693unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextRequest
10694where
10695 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10696{
10697 fn decode(
10698 slot_: ::fidl_next::Slot<'_, Self>,
10699 decoder_: &mut ___D,
10700 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10701 ::fidl_next::munge! {
10702 let Self {
10703
10704 mut start_id,
10705 mut limit,
10706
10707 } = slot_;
10708 }
10709
10710 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_)?;
10711
10712 ::fidl_next::Decode::decode(limit.as_mut(), decoder_)?;
10713
10714 Ok(())
10715 }
10716}
10717
10718#[doc = " Maximum number of items returned by dictionary iterator.\n"]
10719pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;
10720
10721#[derive(PartialEq, Debug)]
10722pub struct DictionaryDrainIteratorGetNextResponse {
10723 pub items: ::std::vec::Vec<crate::DictionaryItem>,
10724
10725 pub end_id: u64,
10726}
10727
10728impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse {
10729 type Encoded = WireDictionaryDrainIteratorGetNextResponse<'static>;
10730}
10731
10732unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextResponse
10733where
10734 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10735 ___E: ::fidl_next::Encoder,
10736 ___E: ::fidl_next::fuchsia::HandleEncoder,
10737{
10738 #[inline]
10739 fn encode(
10740 self,
10741 encoder_: &mut ___E,
10742 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10743 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10744 ::fidl_next::munge! {
10745 let Self::Encoded {
10746 items,
10747 end_id,
10748
10749 } = out_;
10750 }
10751
10752 ::fidl_next::Encode::encode(self.items, encoder_, items)?;
10753
10754 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id)?;
10755
10756 Ok(())
10757 }
10758}
10759
10760impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextResponse {
10761 type EncodedOption =
10762 ::fidl_next::WireBox<'static, WireDictionaryDrainIteratorGetNextResponse<'static>>;
10763}
10764
10765unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextResponse
10766where
10767 ___E: ::fidl_next::Encoder + ?Sized,
10768 DictionaryDrainIteratorGetNextResponse: ::fidl_next::Encode<___E>,
10769{
10770 #[inline]
10771 fn encode_option(
10772 this: ::core::option::Option<Self>,
10773 encoder: &mut ___E,
10774 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10775 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10776 if let Some(inner) = this {
10777 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10778 ::fidl_next::WireBox::encode_present(out);
10779 } else {
10780 ::fidl_next::WireBox::encode_absent(out);
10781 }
10782
10783 Ok(())
10784 }
10785}
10786
10787impl<'de> ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextResponse<'de>>
10788 for DictionaryDrainIteratorGetNextResponse
10789{
10790 #[inline]
10791 fn from_wire(wire: WireDictionaryDrainIteratorGetNextResponse<'de>) -> Self {
10792 Self {
10793 items: ::fidl_next::FromWire::from_wire(wire.items),
10794
10795 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
10796 }
10797 }
10798}
10799
10800impl<'de> ::fidl_next::IntoNatural for WireDictionaryDrainIteratorGetNextResponse<'de> {
10801 type Natural = DictionaryDrainIteratorGetNextResponse;
10802}
10803
10804#[derive(Debug)]
10806#[repr(C)]
10807pub struct WireDictionaryDrainIteratorGetNextResponse<'de> {
10808 pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryItem<'de>>,
10809
10810 pub end_id: ::fidl_next::WireU64,
10811}
10812static_assertions::const_assert_eq!(
10813 std::mem::size_of::<WireDictionaryDrainIteratorGetNextResponse<'_>>(),
10814 24
10815);
10816static_assertions::const_assert_eq!(
10817 std::mem::align_of::<WireDictionaryDrainIteratorGetNextResponse<'_>>(),
10818 8
10819);
10820
10821static_assertions::const_assert_eq!(
10822 std::mem::offset_of!(WireDictionaryDrainIteratorGetNextResponse<'_>, items),
10823 0
10824);
10825
10826static_assertions::const_assert_eq!(
10827 std::mem::offset_of!(WireDictionaryDrainIteratorGetNextResponse<'_>, end_id),
10828 16
10829);
10830
10831unsafe impl ::fidl_next::Wire for WireDictionaryDrainIteratorGetNextResponse<'static> {
10832 type Decoded<'de> = WireDictionaryDrainIteratorGetNextResponse<'de>;
10833
10834 #[inline]
10835 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10836 ::fidl_next::munge! {
10837 let Self {
10838
10839 items,
10840 end_id,
10841
10842 } = &mut *out_;
10843 }
10844
10845 ::fidl_next::Wire::zero_padding(items);
10846
10847 ::fidl_next::Wire::zero_padding(end_id);
10848 }
10849}
10850
10851unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextResponse<'static>
10852where
10853 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10854 ___D: ::fidl_next::Decoder,
10855 ___D: ::fidl_next::fuchsia::HandleDecoder,
10856{
10857 fn decode(
10858 slot_: ::fidl_next::Slot<'_, Self>,
10859 decoder_: &mut ___D,
10860 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10861 ::fidl_next::munge! {
10862 let Self {
10863
10864 mut items,
10865 mut end_id,
10866
10867 } = slot_;
10868 }
10869
10870 ::fidl_next::Decode::decode(items.as_mut(), decoder_)?;
10871
10872 let items = unsafe { items.deref_unchecked() };
10873
10874 if items.len() > 128 {
10875 return Err(::fidl_next::DecodeError::VectorTooLong {
10876 size: items.len() as u64,
10877 limit: 128,
10878 });
10879 }
10880
10881 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_)?;
10882
10883 Ok(())
10884 }
10885}
10886
10887#[derive(PartialEq, Debug)]
10889pub struct DictionaryDrainIterator;
10890
10891pub mod dictionary_drain_iterator {
10892 pub mod prelude {
10893 pub use crate::{
10894 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
10895 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
10896 };
10897
10898 pub use crate::CapabilityStoreError;
10899
10900 pub use crate::DictionaryDrainIteratorGetNextRequest;
10901
10902 pub use crate::DictionaryDrainIteratorGetNextResponse;
10903 }
10904
10905 pub struct GetNext;
10906
10907 impl ::fidl_next::Method for GetNext {
10908 const ORDINAL: u64 = 5728722530628427873;
10909
10910 type Protocol = crate::DictionaryDrainIterator;
10911
10912 type Request = crate::WireDictionaryDrainIteratorGetNextRequest;
10913
10914 type Response = ::fidl_next::WireFlexibleResult<
10915 'static,
10916 crate::WireDictionaryDrainIteratorGetNextResponse<'static>,
10917 crate::WireCapabilityStoreError,
10918 >;
10919 }
10920
10921 mod ___detail {
10922
10923 pub struct GetNext<T0, T1> {
10924 start_id: T0,
10925
10926 limit: T1,
10927 }
10928
10929 impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
10930 where
10931 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
10932 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
10933 {
10934 type Encoded = crate::WireDictionaryDrainIteratorGetNextRequest;
10935 }
10936
10937 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for GetNext<T0, T1>
10938 where
10939 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10940 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
10941 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
10942 {
10943 #[inline]
10944 fn encode(
10945 self,
10946 encoder_: &mut ___E,
10947 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10949 ::fidl_next::munge! {
10950 let Self::Encoded {
10951 start_id,
10952 limit,
10953
10954 } = out_;
10955 }
10956
10957 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
10958
10959 ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
10960
10961 Ok(())
10962 }
10963 }
10964
10965 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryDrainIterator
10966 where
10967 ___T: ::fidl_next::Transport,
10968 {
10969 type Client = DictionaryDrainIteratorClient<___T>;
10970 type Server = DictionaryDrainIteratorServer<___T>;
10971 }
10972
10973 #[repr(transparent)]
10975 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
10976 #[allow(dead_code)]
10977 client: ::fidl_next::protocol::Client<___T>,
10978 }
10979
10980 impl<___T> DictionaryDrainIteratorClient<___T>
10981 where
10982 ___T: ::fidl_next::Transport,
10983 {
10984 #[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"]
10985 pub fn get_next(
10986 &self,
10987
10988 start_id: impl ::fidl_next::Encode<
10989 <___T as ::fidl_next::Transport>::SendBuffer,
10990 Encoded = ::fidl_next::WireU64,
10991 >,
10992
10993 limit: impl ::fidl_next::Encode<
10994 <___T as ::fidl_next::Transport>::SendBuffer,
10995 Encoded = ::fidl_next::WireU32,
10996 >,
10997 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10998 where
10999 <___T as ::fidl_next::Transport>::SendBuffer:
11000 ::fidl_next::encoder::InternalHandleEncoder,
11001 {
11002 self.get_next_with(GetNext { start_id, limit })
11003 }
11004
11005 #[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"]
11006 pub fn get_next_with<___R>(
11007 &self,
11008 request: ___R,
11009 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11010 where
11011 ___R: ::fidl_next::Encode<
11012 <___T as ::fidl_next::Transport>::SendBuffer,
11013 Encoded = crate::WireDictionaryDrainIteratorGetNextRequest,
11014 >,
11015 {
11016 ::fidl_next::TwoWayFuture::from_untyped(
11017 self.client.send_two_way(5728722530628427873, request),
11018 )
11019 }
11020 }
11021
11022 #[repr(transparent)]
11024 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
11025 server: ::fidl_next::protocol::Server<___T>,
11026 }
11027
11028 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11029 }
11030}
11031
11032pub trait DictionaryDrainIteratorClientHandler<
11036 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11037 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11038>
11039{
11040 fn on_unknown_interaction(
11041 &mut self,
11042 ordinal: u64,
11043 ) -> impl ::core::future::Future<
11044 Output = ::core::result::Result<
11045 (),
11046 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11047 >,
11048 > + ::core::marker::Send {
11049 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11050 }
11051}
11052
11053impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
11054where
11055 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
11056 ___T: ::fidl_next::Transport,
11057 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Response:
11058 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11059{
11060 async fn on_event(
11061 handler: &mut ___H,
11062 ordinal: u64,
11063 buffer: ___T::RecvBuffer,
11064 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11065 match ordinal {
11066 ordinal => handler.on_unknown_interaction(ordinal).await,
11067 }
11068 }
11069}
11070
11071pub trait DictionaryDrainIteratorServerHandler<
11075 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11076 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11077>
11078{
11079 #[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"]
11080 fn get_next(
11081 &mut self,
11082
11083 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
11084
11085 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
11086 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11087
11088 fn on_unknown_interaction(
11089 &mut self,
11090 ordinal: u64,
11091 ) -> impl ::core::future::Future<
11092 Output = ::core::result::Result<
11093 (),
11094 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11095 >,
11096 > + ::core::marker::Send {
11097 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11098 }
11099}
11100
11101impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
11102where
11103 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
11104 ___T: ::fidl_next::Transport,
11105 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
11106 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11107{
11108 async fn on_one_way(
11109 handler: &mut ___H,
11110 ordinal: u64,
11111 buffer: ___T::RecvBuffer,
11112 ) -> ::core::result::Result<
11113 (),
11114 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11115 > {
11116 match ordinal {
11117 ordinal => handler.on_unknown_interaction(ordinal).await,
11118 }
11119 }
11120
11121 async fn on_two_way(
11122 handler: &mut ___H,
11123 ordinal: u64,
11124 buffer: ___T::RecvBuffer,
11125 responder: ::fidl_next::protocol::Responder<___T>,
11126 ) -> ::core::result::Result<
11127 (),
11128 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11129 > {
11130 match ordinal {
11131 5728722530628427873 => {
11132 let responder = ::fidl_next::Responder::from_untyped(responder);
11133
11134 match ::fidl_next::DecoderExt::decode(buffer) {
11135 Ok(decoded) => {
11136 handler.get_next(decoded, responder).await;
11137 Ok(())
11138 }
11139 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11140 ordinal: 5728722530628427873,
11141 error,
11142 }),
11143 }
11144 }
11145
11146 ordinal => handler.on_unknown_interaction(ordinal).await,
11147 }
11148 }
11149}
11150
11151#[derive(PartialEq, Clone, Debug)]
11152pub struct DictionaryEnumerateIteratorGetNextRequest {
11153 pub start_id: u64,
11154
11155 pub limit: u32,
11156}
11157
11158impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest {
11159 type Encoded = WireDictionaryEnumerateIteratorGetNextRequest;
11160}
11161
11162unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextRequest
11163where
11164 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11165{
11166 #[inline]
11167 fn encode(
11168 self,
11169 encoder_: &mut ___E,
11170 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11171 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11172 ::fidl_next::munge! {
11173 let Self::Encoded {
11174 start_id,
11175 limit,
11176
11177 } = out_;
11178 }
11179
11180 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
11181
11182 ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
11183
11184 Ok(())
11185 }
11186}
11187
11188unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryEnumerateIteratorGetNextRequest
11189where
11190 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11191{
11192 #[inline]
11193 fn encode_ref(
11194 &self,
11195 encoder_: &mut ___E,
11196 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11197 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11198 ::fidl_next::munge! {
11199 let Self::Encoded {
11200
11201 start_id,
11202 limit,
11203
11204 } = out_;
11205 }
11206
11207 ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id)?;
11208
11209 ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit)?;
11210
11211 Ok(())
11212 }
11213}
11214
11215impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextRequest {
11216 type EncodedOption =
11217 ::fidl_next::WireBox<'static, WireDictionaryEnumerateIteratorGetNextRequest>;
11218}
11219
11220unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextRequest
11221where
11222 ___E: ::fidl_next::Encoder + ?Sized,
11223 DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Encode<___E>,
11224{
11225 #[inline]
11226 fn encode_option(
11227 this: ::core::option::Option<Self>,
11228 encoder: &mut ___E,
11229 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11230 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11231 if let Some(inner) = this {
11232 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11233 ::fidl_next::WireBox::encode_present(out);
11234 } else {
11235 ::fidl_next::WireBox::encode_absent(out);
11236 }
11237
11238 Ok(())
11239 }
11240}
11241
11242unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryEnumerateIteratorGetNextRequest
11243where
11244 ___E: ::fidl_next::Encoder + ?Sized,
11245 DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
11246{
11247 #[inline]
11248 fn encode_option_ref(
11249 this: ::core::option::Option<&Self>,
11250 encoder: &mut ___E,
11251 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11253 if let Some(inner) = this {
11254 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11255 ::fidl_next::WireBox::encode_present(out);
11256 } else {
11257 ::fidl_next::WireBox::encode_absent(out);
11258 }
11259
11260 Ok(())
11261 }
11262}
11263
11264impl ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextRequest>
11265 for DictionaryEnumerateIteratorGetNextRequest
11266{
11267 #[inline]
11268 fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
11269 Self {
11270 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
11271
11272 limit: ::fidl_next::FromWire::from_wire(wire.limit),
11273 }
11274 }
11275}
11276
11277impl ::fidl_next::IntoNatural for WireDictionaryEnumerateIteratorGetNextRequest {
11278 type Natural = DictionaryEnumerateIteratorGetNextRequest;
11279}
11280
11281impl ::fidl_next::FromWireRef<WireDictionaryEnumerateIteratorGetNextRequest>
11282 for DictionaryEnumerateIteratorGetNextRequest
11283{
11284 #[inline]
11285 fn from_wire_ref(wire: &WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
11286 Self {
11287 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
11288
11289 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
11290 }
11291 }
11292}
11293
11294#[derive(Clone, Debug)]
11296#[repr(C)]
11297pub struct WireDictionaryEnumerateIteratorGetNextRequest {
11298 pub start_id: ::fidl_next::WireU64,
11299
11300 pub limit: ::fidl_next::WireU32,
11301}
11302static_assertions::const_assert_eq!(
11303 std::mem::size_of::<WireDictionaryEnumerateIteratorGetNextRequest>(),
11304 16
11305);
11306static_assertions::const_assert_eq!(
11307 std::mem::align_of::<WireDictionaryEnumerateIteratorGetNextRequest>(),
11308 8
11309);
11310
11311static_assertions::const_assert_eq!(
11312 std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextRequest, start_id),
11313 0
11314);
11315
11316static_assertions::const_assert_eq!(
11317 std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextRequest, limit),
11318 8
11319);
11320
11321unsafe impl ::fidl_next::Wire for WireDictionaryEnumerateIteratorGetNextRequest {
11322 type Decoded<'de> = WireDictionaryEnumerateIteratorGetNextRequest;
11323
11324 #[inline]
11325 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11326 ::fidl_next::munge! {
11327 let Self {
11328
11329 start_id,
11330 limit,
11331
11332 } = &mut *out_;
11333 }
11334
11335 ::fidl_next::Wire::zero_padding(start_id);
11336
11337 ::fidl_next::Wire::zero_padding(limit);
11338
11339 unsafe {
11340 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11341 }
11342 }
11343}
11344
11345unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryEnumerateIteratorGetNextRequest
11346where
11347 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11348{
11349 fn decode(
11350 slot_: ::fidl_next::Slot<'_, Self>,
11351 decoder_: &mut ___D,
11352 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11353 ::fidl_next::munge! {
11354 let Self {
11355
11356 mut start_id,
11357 mut limit,
11358
11359 } = slot_;
11360 }
11361
11362 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_)?;
11363
11364 ::fidl_next::Decode::decode(limit.as_mut(), decoder_)?;
11365
11366 Ok(())
11367 }
11368}
11369
11370#[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"]
11371#[derive(PartialEq, Debug)]
11372pub struct DictionaryOptionalItem {
11373 pub key: ::std::string::String,
11374
11375 pub value: ::core::option::Option<::std::boxed::Box<crate::WrappedCapabilityId>>,
11376}
11377
11378impl ::fidl_next::Encodable for DictionaryOptionalItem {
11379 type Encoded = WireDictionaryOptionalItem<'static>;
11380}
11381
11382unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryOptionalItem
11383where
11384 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11385 ___E: ::fidl_next::Encoder,
11386 ___E: ::fidl_next::fuchsia::HandleEncoder,
11387{
11388 #[inline]
11389 fn encode(
11390 self,
11391 encoder_: &mut ___E,
11392 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11393 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11394 ::fidl_next::munge! {
11395 let Self::Encoded {
11396 key,
11397 value,
11398
11399 } = out_;
11400 }
11401
11402 ::fidl_next::Encode::encode(self.key, encoder_, key)?;
11403
11404 ::fidl_next::Encode::encode(self.value, encoder_, value)?;
11405
11406 Ok(())
11407 }
11408}
11409
11410impl ::fidl_next::EncodableOption for DictionaryOptionalItem {
11411 type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryOptionalItem<'static>>;
11412}
11413
11414unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryOptionalItem
11415where
11416 ___E: ::fidl_next::Encoder + ?Sized,
11417 DictionaryOptionalItem: ::fidl_next::Encode<___E>,
11418{
11419 #[inline]
11420 fn encode_option(
11421 this: ::core::option::Option<Self>,
11422 encoder: &mut ___E,
11423 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11424 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11425 if let Some(inner) = this {
11426 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11427 ::fidl_next::WireBox::encode_present(out);
11428 } else {
11429 ::fidl_next::WireBox::encode_absent(out);
11430 }
11431
11432 Ok(())
11433 }
11434}
11435
11436impl<'de> ::fidl_next::FromWire<WireDictionaryOptionalItem<'de>> for DictionaryOptionalItem {
11437 #[inline]
11438 fn from_wire(wire: WireDictionaryOptionalItem<'de>) -> Self {
11439 Self {
11440 key: ::fidl_next::FromWire::from_wire(wire.key),
11441
11442 value: ::fidl_next::FromWire::from_wire(wire.value),
11443 }
11444 }
11445}
11446
11447impl<'de> ::fidl_next::IntoNatural for WireDictionaryOptionalItem<'de> {
11448 type Natural = DictionaryOptionalItem;
11449}
11450
11451#[derive(Debug)]
11453#[repr(C)]
11454pub struct WireDictionaryOptionalItem<'de> {
11455 pub key: ::fidl_next::WireString<'de>,
11456
11457 pub value: ::fidl_next::WireBox<'de, crate::WireWrappedCapabilityId>,
11458}
11459static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryOptionalItem<'_>>(), 24);
11460static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryOptionalItem<'_>>(), 8);
11461
11462static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryOptionalItem<'_>, key), 0);
11463
11464static_assertions::const_assert_eq!(
11465 std::mem::offset_of!(WireDictionaryOptionalItem<'_>, value),
11466 16
11467);
11468
11469unsafe impl ::fidl_next::Wire for WireDictionaryOptionalItem<'static> {
11470 type Decoded<'de> = WireDictionaryOptionalItem<'de>;
11471
11472 #[inline]
11473 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11474 ::fidl_next::munge! {
11475 let Self {
11476
11477 key,
11478 value,
11479
11480 } = &mut *out_;
11481 }
11482
11483 ::fidl_next::Wire::zero_padding(key);
11484
11485 ::fidl_next::Wire::zero_padding(value);
11486 }
11487}
11488
11489unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryOptionalItem<'static>
11490where
11491 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11492 ___D: ::fidl_next::Decoder,
11493 ___D: ::fidl_next::fuchsia::HandleDecoder,
11494{
11495 fn decode(
11496 slot_: ::fidl_next::Slot<'_, Self>,
11497 decoder_: &mut ___D,
11498 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11499 ::fidl_next::munge! {
11500 let Self {
11501
11502 mut key,
11503 mut value,
11504
11505 } = slot_;
11506 }
11507
11508 ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
11509
11510 let key = unsafe { key.deref_unchecked() };
11511
11512 if key.len() > 255 {
11513 return Err(::fidl_next::DecodeError::VectorTooLong {
11514 size: key.len() as u64,
11515 limit: 255,
11516 });
11517 }
11518
11519 ::fidl_next::Decode::decode(value.as_mut(), decoder_)?;
11520
11521 Ok(())
11522 }
11523}
11524
11525#[derive(PartialEq, Debug)]
11526pub struct DictionaryEnumerateIteratorGetNextResponse {
11527 pub items: ::std::vec::Vec<crate::DictionaryOptionalItem>,
11528
11529 pub end_id: u64,
11530}
11531
11532impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse {
11533 type Encoded = WireDictionaryEnumerateIteratorGetNextResponse<'static>;
11534}
11535
11536unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextResponse
11537where
11538 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11539 ___E: ::fidl_next::Encoder,
11540 ___E: ::fidl_next::fuchsia::HandleEncoder,
11541{
11542 #[inline]
11543 fn encode(
11544 self,
11545 encoder_: &mut ___E,
11546 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11547 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11548 ::fidl_next::munge! {
11549 let Self::Encoded {
11550 items,
11551 end_id,
11552
11553 } = out_;
11554 }
11555
11556 ::fidl_next::Encode::encode(self.items, encoder_, items)?;
11557
11558 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id)?;
11559
11560 Ok(())
11561 }
11562}
11563
11564impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextResponse {
11565 type EncodedOption =
11566 ::fidl_next::WireBox<'static, WireDictionaryEnumerateIteratorGetNextResponse<'static>>;
11567}
11568
11569unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextResponse
11570where
11571 ___E: ::fidl_next::Encoder + ?Sized,
11572 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<___E>,
11573{
11574 #[inline]
11575 fn encode_option(
11576 this: ::core::option::Option<Self>,
11577 encoder: &mut ___E,
11578 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11579 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11580 if let Some(inner) = this {
11581 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11582 ::fidl_next::WireBox::encode_present(out);
11583 } else {
11584 ::fidl_next::WireBox::encode_absent(out);
11585 }
11586
11587 Ok(())
11588 }
11589}
11590
11591impl<'de> ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextResponse<'de>>
11592 for DictionaryEnumerateIteratorGetNextResponse
11593{
11594 #[inline]
11595 fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
11596 Self {
11597 items: ::fidl_next::FromWire::from_wire(wire.items),
11598
11599 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
11600 }
11601 }
11602}
11603
11604impl<'de> ::fidl_next::IntoNatural for WireDictionaryEnumerateIteratorGetNextResponse<'de> {
11605 type Natural = DictionaryEnumerateIteratorGetNextResponse;
11606}
11607
11608#[derive(Debug)]
11610#[repr(C)]
11611pub struct WireDictionaryEnumerateIteratorGetNextResponse<'de> {
11612 pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryOptionalItem<'de>>,
11613
11614 pub end_id: ::fidl_next::WireU64,
11615}
11616static_assertions::const_assert_eq!(
11617 std::mem::size_of::<WireDictionaryEnumerateIteratorGetNextResponse<'_>>(),
11618 24
11619);
11620static_assertions::const_assert_eq!(
11621 std::mem::align_of::<WireDictionaryEnumerateIteratorGetNextResponse<'_>>(),
11622 8
11623);
11624
11625static_assertions::const_assert_eq!(
11626 std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextResponse<'_>, items),
11627 0
11628);
11629
11630static_assertions::const_assert_eq!(
11631 std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
11632 16
11633);
11634
11635unsafe impl ::fidl_next::Wire for WireDictionaryEnumerateIteratorGetNextResponse<'static> {
11636 type Decoded<'de> = WireDictionaryEnumerateIteratorGetNextResponse<'de>;
11637
11638 #[inline]
11639 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11640 ::fidl_next::munge! {
11641 let Self {
11642
11643 items,
11644 end_id,
11645
11646 } = &mut *out_;
11647 }
11648
11649 ::fidl_next::Wire::zero_padding(items);
11650
11651 ::fidl_next::Wire::zero_padding(end_id);
11652 }
11653}
11654
11655unsafe impl<___D> ::fidl_next::Decode<___D>
11656 for WireDictionaryEnumerateIteratorGetNextResponse<'static>
11657where
11658 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11659 ___D: ::fidl_next::Decoder,
11660 ___D: ::fidl_next::fuchsia::HandleDecoder,
11661{
11662 fn decode(
11663 slot_: ::fidl_next::Slot<'_, Self>,
11664 decoder_: &mut ___D,
11665 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11666 ::fidl_next::munge! {
11667 let Self {
11668
11669 mut items,
11670 mut end_id,
11671
11672 } = slot_;
11673 }
11674
11675 ::fidl_next::Decode::decode(items.as_mut(), decoder_)?;
11676
11677 let items = unsafe { items.deref_unchecked() };
11678
11679 if items.len() > 128 {
11680 return Err(::fidl_next::DecodeError::VectorTooLong {
11681 size: items.len() as u64,
11682 limit: 128,
11683 });
11684 }
11685
11686 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_)?;
11687
11688 Ok(())
11689 }
11690}
11691
11692#[derive(PartialEq, Debug)]
11694pub struct DictionaryEnumerateIterator;
11695
11696pub mod dictionary_enumerate_iterator {
11697 pub mod prelude {
11698 pub use crate::{
11699 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
11700 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
11701 };
11702
11703 pub use crate::CapabilityStoreError;
11704
11705 pub use crate::DictionaryEnumerateIteratorGetNextRequest;
11706
11707 pub use crate::DictionaryEnumerateIteratorGetNextResponse;
11708 }
11709
11710 pub struct GetNext;
11711
11712 impl ::fidl_next::Method for GetNext {
11713 const ORDINAL: u64 = 1511164556663256527;
11714
11715 type Protocol = crate::DictionaryEnumerateIterator;
11716
11717 type Request = crate::WireDictionaryEnumerateIteratorGetNextRequest;
11718
11719 type Response = ::fidl_next::WireFlexibleResult<
11720 'static,
11721 crate::WireDictionaryEnumerateIteratorGetNextResponse<'static>,
11722 crate::WireCapabilityStoreError,
11723 >;
11724 }
11725
11726 mod ___detail {
11727
11728 pub struct GetNext<T0, T1> {
11729 start_id: T0,
11730
11731 limit: T1,
11732 }
11733
11734 impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
11735 where
11736 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
11737 T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
11738 {
11739 type Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest;
11740 }
11741
11742 unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for GetNext<T0, T1>
11743 where
11744 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11745 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
11746 T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
11747 {
11748 #[inline]
11749 fn encode(
11750 self,
11751 encoder_: &mut ___E,
11752 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11754 ::fidl_next::munge! {
11755 let Self::Encoded {
11756 start_id,
11757 limit,
11758
11759 } = out_;
11760 }
11761
11762 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
11763
11764 ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
11765
11766 Ok(())
11767 }
11768 }
11769
11770 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryEnumerateIterator
11771 where
11772 ___T: ::fidl_next::Transport,
11773 {
11774 type Client = DictionaryEnumerateIteratorClient<___T>;
11775 type Server = DictionaryEnumerateIteratorServer<___T>;
11776 }
11777
11778 #[repr(transparent)]
11780 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
11781 #[allow(dead_code)]
11782 client: ::fidl_next::protocol::Client<___T>,
11783 }
11784
11785 impl<___T> DictionaryEnumerateIteratorClient<___T>
11786 where
11787 ___T: ::fidl_next::Transport,
11788 {
11789 #[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"]
11790 pub fn get_next(
11791 &self,
11792
11793 start_id: impl ::fidl_next::Encode<
11794 <___T as ::fidl_next::Transport>::SendBuffer,
11795 Encoded = ::fidl_next::WireU64,
11796 >,
11797
11798 limit: impl ::fidl_next::Encode<
11799 <___T as ::fidl_next::Transport>::SendBuffer,
11800 Encoded = ::fidl_next::WireU32,
11801 >,
11802 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11803 where
11804 <___T as ::fidl_next::Transport>::SendBuffer:
11805 ::fidl_next::encoder::InternalHandleEncoder,
11806 {
11807 self.get_next_with(GetNext { start_id, limit })
11808 }
11809
11810 #[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"]
11811 pub fn get_next_with<___R>(
11812 &self,
11813 request: ___R,
11814 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11815 where
11816 ___R: ::fidl_next::Encode<
11817 <___T as ::fidl_next::Transport>::SendBuffer,
11818 Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest,
11819 >,
11820 {
11821 ::fidl_next::TwoWayFuture::from_untyped(
11822 self.client.send_two_way(1511164556663256527, request),
11823 )
11824 }
11825 }
11826
11827 #[repr(transparent)]
11829 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
11830 server: ::fidl_next::protocol::Server<___T>,
11831 }
11832
11833 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11834 }
11835}
11836
11837pub trait DictionaryEnumerateIteratorClientHandler<
11841 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11842 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11843>
11844{
11845 fn on_unknown_interaction(
11846 &mut self,
11847 ordinal: u64,
11848 ) -> impl ::core::future::Future<
11849 Output = ::core::result::Result<
11850 (),
11851 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11852 >,
11853 > + ::core::marker::Send {
11854 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11855 }
11856}
11857
11858impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
11859where
11860 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
11861 ___T: ::fidl_next::Transport,
11862 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Response:
11863 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11864{
11865 async fn on_event(
11866 handler: &mut ___H,
11867 ordinal: u64,
11868 buffer: ___T::RecvBuffer,
11869 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11870 match ordinal {
11871 ordinal => handler.on_unknown_interaction(ordinal).await,
11872 }
11873 }
11874}
11875
11876pub trait DictionaryEnumerateIteratorServerHandler<
11880 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11881 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11882>
11883{
11884 #[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"]
11885 fn get_next(
11886 &mut self,
11887
11888 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
11889
11890 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
11891 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11892
11893 fn on_unknown_interaction(
11894 &mut self,
11895 ordinal: u64,
11896 ) -> impl ::core::future::Future<
11897 Output = ::core::result::Result<
11898 (),
11899 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11900 >,
11901 > + ::core::marker::Send {
11902 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11903 }
11904}
11905
11906impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
11907where
11908 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
11909 ___T: ::fidl_next::Transport,
11910 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
11911 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11912{
11913 async fn on_one_way(
11914 handler: &mut ___H,
11915 ordinal: u64,
11916 buffer: ___T::RecvBuffer,
11917 ) -> ::core::result::Result<
11918 (),
11919 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11920 > {
11921 match ordinal {
11922 ordinal => handler.on_unknown_interaction(ordinal).await,
11923 }
11924 }
11925
11926 async fn on_two_way(
11927 handler: &mut ___H,
11928 ordinal: u64,
11929 buffer: ___T::RecvBuffer,
11930 responder: ::fidl_next::protocol::Responder<___T>,
11931 ) -> ::core::result::Result<
11932 (),
11933 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11934 > {
11935 match ordinal {
11936 1511164556663256527 => {
11937 let responder = ::fidl_next::Responder::from_untyped(responder);
11938
11939 match ::fidl_next::DecoderExt::decode(buffer) {
11940 Ok(decoded) => {
11941 handler.get_next(decoded, responder).await;
11942 Ok(())
11943 }
11944 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11945 ordinal: 1511164556663256527,
11946 error,
11947 }),
11948 }
11949 }
11950
11951 ordinal => handler.on_unknown_interaction(ordinal).await,
11952 }
11953 }
11954}
11955
11956#[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
11957#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11958#[repr(u32)]
11959pub enum DictionaryError {
11960 NotFound = 1,
11961 AlreadyExists = 2,
11962 BadCapability = 3,
11963 InvalidKey = 4,
11964 NotCloneable = 5,
11965 UnknownOrdinal_(u32) = 6,
11966}
11967
11968impl ::fidl_next::Encodable for DictionaryError {
11969 type Encoded = WireDictionaryError;
11970}
11971impl ::std::convert::From<u32> for DictionaryError {
11972 fn from(value: u32) -> Self {
11973 match value {
11974 1 => Self::NotFound,
11975 2 => Self::AlreadyExists,
11976 3 => Self::BadCapability,
11977 4 => Self::InvalidKey,
11978 5 => Self::NotCloneable,
11979
11980 _ => Self::UnknownOrdinal_(value),
11981 }
11982 }
11983}
11984
11985unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryError
11986where
11987 ___E: ?Sized,
11988{
11989 #[inline]
11990 fn encode(
11991 self,
11992 encoder: &mut ___E,
11993 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11994 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11995 ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
11996 }
11997}
11998
11999unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryError
12000where
12001 ___E: ?Sized,
12002{
12003 #[inline]
12004 fn encode_ref(
12005 &self,
12006 encoder: &mut ___E,
12007 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12008 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12009 ::fidl_next::munge!(let WireDictionaryError { value } = out);
12010 let _ = value.write(::fidl_next::WireU32::from(match *self {
12011 Self::NotFound => 1,
12012
12013 Self::AlreadyExists => 2,
12014
12015 Self::BadCapability => 3,
12016
12017 Self::InvalidKey => 4,
12018
12019 Self::NotCloneable => 5,
12020
12021 Self::UnknownOrdinal_(value) => value,
12022 }));
12023
12024 Ok(())
12025 }
12026}
12027
12028impl ::core::convert::From<WireDictionaryError> for DictionaryError {
12029 fn from(wire: WireDictionaryError) -> Self {
12030 match u32::from(wire.value) {
12031 1 => Self::NotFound,
12032
12033 2 => Self::AlreadyExists,
12034
12035 3 => Self::BadCapability,
12036
12037 4 => Self::InvalidKey,
12038
12039 5 => Self::NotCloneable,
12040
12041 value => Self::UnknownOrdinal_(value),
12042 }
12043 }
12044}
12045
12046impl ::fidl_next::FromWire<WireDictionaryError> for DictionaryError {
12047 #[inline]
12048 fn from_wire(wire: WireDictionaryError) -> Self {
12049 Self::from(wire)
12050 }
12051}
12052
12053impl ::fidl_next::IntoNatural for WireDictionaryError {
12054 type Natural = DictionaryError;
12055}
12056
12057impl ::fidl_next::FromWireRef<WireDictionaryError> for DictionaryError {
12058 #[inline]
12059 fn from_wire_ref(wire: &WireDictionaryError) -> Self {
12060 Self::from(*wire)
12061 }
12062}
12063
12064#[derive(Clone, Copy, Debug, PartialEq, Eq)]
12066#[repr(transparent)]
12067pub struct WireDictionaryError {
12068 value: ::fidl_next::WireU32,
12069}
12070
12071unsafe impl ::fidl_next::Wire for WireDictionaryError {
12072 type Decoded<'de> = Self;
12073
12074 #[inline]
12075 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12076 }
12078}
12079
12080impl WireDictionaryError {
12081 pub const NOT_FOUND: WireDictionaryError =
12082 WireDictionaryError { value: ::fidl_next::WireU32(1) };
12083
12084 pub const ALREADY_EXISTS: WireDictionaryError =
12085 WireDictionaryError { value: ::fidl_next::WireU32(2) };
12086
12087 pub const BAD_CAPABILITY: WireDictionaryError =
12088 WireDictionaryError { value: ::fidl_next::WireU32(3) };
12089
12090 pub const INVALID_KEY: WireDictionaryError =
12091 WireDictionaryError { value: ::fidl_next::WireU32(4) };
12092
12093 pub const NOT_CLONEABLE: WireDictionaryError =
12094 WireDictionaryError { value: ::fidl_next::WireU32(5) };
12095}
12096
12097unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryError
12098where
12099 ___D: ?Sized,
12100{
12101 fn decode(
12102 slot: ::fidl_next::Slot<'_, Self>,
12103 _: &mut ___D,
12104 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12105 Ok(())
12106 }
12107}
12108
12109impl ::core::convert::From<DictionaryError> for WireDictionaryError {
12110 fn from(natural: DictionaryError) -> Self {
12111 match natural {
12112 DictionaryError::NotFound => WireDictionaryError::NOT_FOUND,
12113
12114 DictionaryError::AlreadyExists => WireDictionaryError::ALREADY_EXISTS,
12115
12116 DictionaryError::BadCapability => WireDictionaryError::BAD_CAPABILITY,
12117
12118 DictionaryError::InvalidKey => WireDictionaryError::INVALID_KEY,
12119
12120 DictionaryError::NotCloneable => WireDictionaryError::NOT_CLONEABLE,
12121
12122 DictionaryError::UnknownOrdinal_(value) => {
12123 WireDictionaryError { value: ::fidl_next::WireU32::from(value) }
12124 }
12125 }
12126 }
12127}
12128
12129#[derive(PartialEq, Debug)]
12130pub struct DictionaryKeysIteratorGetNextResponse {
12131 pub keys: ::std::vec::Vec<::std::string::String>,
12132}
12133
12134impl ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse {
12135 type Encoded = WireDictionaryKeysIteratorGetNextResponse<'static>;
12136}
12137
12138unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse
12139where
12140 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12141 ___E: ::fidl_next::Encoder,
12142 ___E: ::fidl_next::fuchsia::HandleEncoder,
12143{
12144 #[inline]
12145 fn encode(
12146 self,
12147 encoder_: &mut ___E,
12148 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12149 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12150 ::fidl_next::munge! {
12151 let Self::Encoded {
12152 keys,
12153
12154 } = out_;
12155 }
12156
12157 ::fidl_next::Encode::encode(self.keys, encoder_, keys)?;
12158
12159 Ok(())
12160 }
12161}
12162
12163impl ::fidl_next::EncodableOption for DictionaryKeysIteratorGetNextResponse {
12164 type EncodedOption =
12165 ::fidl_next::WireBox<'static, WireDictionaryKeysIteratorGetNextResponse<'static>>;
12166}
12167
12168unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryKeysIteratorGetNextResponse
12169where
12170 ___E: ::fidl_next::Encoder + ?Sized,
12171 DictionaryKeysIteratorGetNextResponse: ::fidl_next::Encode<___E>,
12172{
12173 #[inline]
12174 fn encode_option(
12175 this: ::core::option::Option<Self>,
12176 encoder: &mut ___E,
12177 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12178 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12179 if let Some(inner) = this {
12180 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12181 ::fidl_next::WireBox::encode_present(out);
12182 } else {
12183 ::fidl_next::WireBox::encode_absent(out);
12184 }
12185
12186 Ok(())
12187 }
12188}
12189
12190impl<'de> ::fidl_next::FromWire<WireDictionaryKeysIteratorGetNextResponse<'de>>
12191 for DictionaryKeysIteratorGetNextResponse
12192{
12193 #[inline]
12194 fn from_wire(wire: WireDictionaryKeysIteratorGetNextResponse<'de>) -> Self {
12195 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
12196 }
12197}
12198
12199impl<'de> ::fidl_next::IntoNatural for WireDictionaryKeysIteratorGetNextResponse<'de> {
12200 type Natural = DictionaryKeysIteratorGetNextResponse;
12201}
12202
12203#[derive(Debug)]
12205#[repr(C)]
12206pub struct WireDictionaryKeysIteratorGetNextResponse<'de> {
12207 pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
12208}
12209static_assertions::const_assert_eq!(
12210 std::mem::size_of::<WireDictionaryKeysIteratorGetNextResponse<'_>>(),
12211 16
12212);
12213static_assertions::const_assert_eq!(
12214 std::mem::align_of::<WireDictionaryKeysIteratorGetNextResponse<'_>>(),
12215 8
12216);
12217
12218static_assertions::const_assert_eq!(
12219 std::mem::offset_of!(WireDictionaryKeysIteratorGetNextResponse<'_>, keys),
12220 0
12221);
12222
12223unsafe impl ::fidl_next::Wire for WireDictionaryKeysIteratorGetNextResponse<'static> {
12224 type Decoded<'de> = WireDictionaryKeysIteratorGetNextResponse<'de>;
12225
12226 #[inline]
12227 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12228 ::fidl_next::munge! {
12229 let Self {
12230
12231 keys,
12232
12233 } = &mut *out_;
12234 }
12235
12236 ::fidl_next::Wire::zero_padding(keys);
12237 }
12238}
12239
12240unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryKeysIteratorGetNextResponse<'static>
12241where
12242 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12243 ___D: ::fidl_next::Decoder,
12244 ___D: ::fidl_next::fuchsia::HandleDecoder,
12245{
12246 fn decode(
12247 slot_: ::fidl_next::Slot<'_, Self>,
12248 decoder_: &mut ___D,
12249 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12250 ::fidl_next::munge! {
12251 let Self {
12252
12253 mut keys,
12254
12255 } = slot_;
12256 }
12257
12258 ::fidl_next::Decode::decode(keys.as_mut(), decoder_)?;
12259
12260 let keys = unsafe { keys.deref_unchecked() };
12261
12262 if keys.len() > 128 {
12263 return Err(::fidl_next::DecodeError::VectorTooLong {
12264 size: keys.len() as u64,
12265 limit: 128,
12266 });
12267 }
12268
12269 Ok(())
12270 }
12271}
12272
12273#[derive(PartialEq, Debug)]
12275pub struct DictionaryKeysIterator;
12276
12277pub mod dictionary_keys_iterator {
12278 pub mod prelude {
12279 pub use crate::{
12280 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
12281 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
12282 };
12283
12284 pub use crate::DictionaryKeysIteratorGetNextResponse;
12285 }
12286
12287 pub struct GetNext;
12288
12289 impl ::fidl_next::Method for GetNext {
12290 const ORDINAL: u64 = 4987781442555247955;
12291
12292 type Protocol = crate::DictionaryKeysIterator;
12293
12294 type Request = ();
12295
12296 type Response = ::fidl_next::WireFlexible<
12297 'static,
12298 crate::WireDictionaryKeysIteratorGetNextResponse<'static>,
12299 >;
12300 }
12301
12302 mod ___detail {
12303
12304 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryKeysIterator
12305 where
12306 ___T: ::fidl_next::Transport,
12307 {
12308 type Client = DictionaryKeysIteratorClient<___T>;
12309 type Server = DictionaryKeysIteratorServer<___T>;
12310 }
12311
12312 #[repr(transparent)]
12314 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
12315 #[allow(dead_code)]
12316 client: ::fidl_next::protocol::Client<___T>,
12317 }
12318
12319 impl<___T> DictionaryKeysIteratorClient<___T>
12320 where
12321 ___T: ::fidl_next::Transport,
12322 {
12323 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
12324 ::fidl_next::TwoWayFuture::from_untyped(
12325 self.client.send_two_way(4987781442555247955, ()),
12326 )
12327 }
12328 }
12329
12330 #[repr(transparent)]
12332 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
12333 server: ::fidl_next::protocol::Server<___T>,
12334 }
12335
12336 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
12337 }
12338}
12339
12340pub trait DictionaryKeysIteratorClientHandler<
12344 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12345 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12346>
12347{
12348 fn on_unknown_interaction(
12349 &mut self,
12350 ordinal: u64,
12351 ) -> impl ::core::future::Future<
12352 Output = ::core::result::Result<
12353 (),
12354 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12355 >,
12356 > + ::core::marker::Send {
12357 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12358 }
12359}
12360
12361impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
12362where
12363 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
12364 ___T: ::fidl_next::Transport,
12365 <dictionary_keys_iterator::GetNext as ::fidl_next::Method>::Response:
12366 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12367{
12368 async fn on_event(
12369 handler: &mut ___H,
12370 ordinal: u64,
12371 buffer: ___T::RecvBuffer,
12372 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12373 match ordinal {
12374 ordinal => handler.on_unknown_interaction(ordinal).await,
12375 }
12376 }
12377}
12378
12379pub trait DictionaryKeysIteratorServerHandler<
12383 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12384 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12385>
12386{
12387 fn get_next(
12388 &mut self,
12389
12390 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
12391 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12392
12393 fn on_unknown_interaction(
12394 &mut self,
12395 ordinal: u64,
12396 ) -> impl ::core::future::Future<
12397 Output = ::core::result::Result<
12398 (),
12399 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12400 >,
12401 > + ::core::marker::Send {
12402 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12403 }
12404}
12405
12406impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
12407where
12408 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
12409 ___T: ::fidl_next::Transport,
12410{
12411 async fn on_one_way(
12412 handler: &mut ___H,
12413 ordinal: u64,
12414 buffer: ___T::RecvBuffer,
12415 ) -> ::core::result::Result<
12416 (),
12417 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12418 > {
12419 match ordinal {
12420 ordinal => handler.on_unknown_interaction(ordinal).await,
12421 }
12422 }
12423
12424 async fn on_two_way(
12425 handler: &mut ___H,
12426 ordinal: u64,
12427 buffer: ___T::RecvBuffer,
12428 responder: ::fidl_next::protocol::Responder<___T>,
12429 ) -> ::core::result::Result<
12430 (),
12431 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12432 > {
12433 match ordinal {
12434 4987781442555247955 => {
12435 let responder = ::fidl_next::Responder::from_untyped(responder);
12436
12437 handler.get_next(responder).await;
12438 Ok(())
12439 }
12440
12441 ordinal => handler.on_unknown_interaction(ordinal).await,
12442 }
12443 }
12444}
12445
12446#[derive(PartialEq, Debug)]
12447pub enum DictionaryRouterRouteResponse {
12448 Dictionary(crate::DictionaryRef),
12449
12450 Unavailable(crate::Unit),
12451}
12452
12453impl ::fidl_next::Encodable for DictionaryRouterRouteResponse {
12454 type Encoded = WireDictionaryRouterRouteResponse;
12455}
12456
12457unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRouterRouteResponse
12458where
12459 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12460 ___E: ::fidl_next::fuchsia::HandleEncoder,
12461{
12462 #[inline]
12463 fn encode(
12464 self,
12465 encoder: &mut ___E,
12466 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12467 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12468 ::fidl_next::munge!(let WireDictionaryRouterRouteResponse { raw, _phantom: _ } = out);
12469
12470 match self {
12471 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12472 ___E,
12473 crate::DictionaryRef,
12474 >(value, 1, encoder, raw)?,
12475
12476 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12477 ___E,
12478 crate::Unit,
12479 >(value, 2, encoder, raw)?,
12480 }
12481
12482 Ok(())
12483 }
12484}
12485
12486impl ::fidl_next::EncodableOption for DictionaryRouterRouteResponse {
12487 type EncodedOption = WireOptionalDictionaryRouterRouteResponse;
12488}
12489
12490unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRouterRouteResponse
12491where
12492 ___E: ?Sized,
12493 DictionaryRouterRouteResponse: ::fidl_next::Encode<___E>,
12494{
12495 #[inline]
12496 fn encode_option(
12497 this: ::core::option::Option<Self>,
12498 encoder: &mut ___E,
12499 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12500 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12501 ::fidl_next::munge!(let WireOptionalDictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
12502
12503 if let Some(inner) = this {
12504 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
12505 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
12506 } else {
12507 ::fidl_next::RawWireUnion::encode_absent(raw);
12508 }
12509
12510 Ok(())
12511 }
12512}
12513
12514impl ::fidl_next::FromWire<WireDictionaryRouterRouteResponse> for DictionaryRouterRouteResponse {
12515 #[inline]
12516 fn from_wire(wire: WireDictionaryRouterRouteResponse) -> Self {
12517 let wire = ::core::mem::ManuallyDrop::new(wire);
12518 match wire.raw.ordinal() {
12519 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
12520 wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
12521 })),
12522
12523 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
12524 wire.raw.get().read_unchecked::<crate::WireUnit>()
12525 })),
12526
12527 _ => unsafe { ::core::hint::unreachable_unchecked() },
12528 }
12529 }
12530}
12531
12532impl ::fidl_next::IntoNatural for WireDictionaryRouterRouteResponse {
12533 type Natural = DictionaryRouterRouteResponse;
12534}
12535
12536impl ::fidl_next::FromWireOption<WireOptionalDictionaryRouterRouteResponse>
12537 for DictionaryRouterRouteResponse
12538{
12539 #[inline]
12540 fn from_wire_option(
12541 wire: WireOptionalDictionaryRouterRouteResponse,
12542 ) -> ::core::option::Option<Self> {
12543 if let Some(inner) = wire.into_option() {
12544 Some(::fidl_next::FromWire::from_wire(inner))
12545 } else {
12546 None
12547 }
12548 }
12549}
12550
12551impl ::fidl_next::IntoNatural for WireOptionalDictionaryRouterRouteResponse {
12552 type Natural = ::core::option::Option<DictionaryRouterRouteResponse>;
12553}
12554
12555impl ::fidl_next::FromWireOption<WireOptionalDictionaryRouterRouteResponse>
12556 for Box<DictionaryRouterRouteResponse>
12557{
12558 #[inline]
12559 fn from_wire_option(
12560 wire: WireOptionalDictionaryRouterRouteResponse,
12561 ) -> ::core::option::Option<Self> {
12562 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
12563 WireOptionalDictionaryRouterRouteResponse,
12564 >>::from_wire_option(wire)
12565 .map(Box::new)
12566 }
12567}
12568
12569#[repr(transparent)]
12571pub struct WireDictionaryRouterRouteResponse {
12572 raw: ::fidl_next::RawWireUnion,
12573 _phantom: ::core::marker::PhantomData<()>,
12574}
12575
12576impl Drop for WireDictionaryRouterRouteResponse {
12577 fn drop(&mut self) {
12578 match self.raw.ordinal() {
12579 1 => {
12580 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDictionaryRef>() };
12581 }
12582
12583 2 => {
12584 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
12585 }
12586
12587 _ => unsafe { ::core::hint::unreachable_unchecked() },
12588 }
12589 }
12590}
12591
12592unsafe impl ::fidl_next::Wire for WireDictionaryRouterRouteResponse {
12593 type Decoded<'de> = WireDictionaryRouterRouteResponse;
12594
12595 #[inline]
12596 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12597 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12598 ::fidl_next::RawWireUnion::zero_padding(raw);
12599 }
12600}
12601
12602pub mod dictionary_router_route_response {
12603 pub enum Ref<'de> {
12604 Dictionary(&'de crate::WireDictionaryRef),
12605
12606 Unavailable(&'de crate::WireUnit),
12607 }
12608}
12609
12610impl WireDictionaryRouterRouteResponse {
12611 pub fn as_ref(&self) -> crate::dictionary_router_route_response::Ref<'_> {
12612 match self.raw.ordinal() {
12613 1 => crate::dictionary_router_route_response::Ref::Dictionary(unsafe {
12614 self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
12615 }),
12616
12617 2 => crate::dictionary_router_route_response::Ref::Unavailable(unsafe {
12618 self.raw.get().deref_unchecked::<crate::WireUnit>()
12619 }),
12620
12621 _ => unsafe { ::core::hint::unreachable_unchecked() },
12622 }
12623 }
12624}
12625
12626unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryRouterRouteResponse
12627where
12628 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12629 ___D: ::fidl_next::fuchsia::HandleDecoder,
12630{
12631 fn decode(
12632 mut slot: ::fidl_next::Slot<'_, Self>,
12633 decoder: &mut ___D,
12634 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12635 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12636 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12637 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDictionaryRef>(
12638 raw, decoder,
12639 )?,
12640
12641 2 => {
12642 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
12643 }
12644
12645 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12646 }
12647
12648 Ok(())
12649 }
12650}
12651
12652impl ::core::fmt::Debug for WireDictionaryRouterRouteResponse {
12653 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12654 match self.raw.ordinal() {
12655 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionaryRef>().fmt(f) },
12656 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
12657 _ => unsafe { ::core::hint::unreachable_unchecked() },
12658 }
12659 }
12660}
12661
12662#[repr(transparent)]
12663pub struct WireOptionalDictionaryRouterRouteResponse {
12664 raw: ::fidl_next::RawWireUnion,
12665 _phantom: ::core::marker::PhantomData<()>,
12666}
12667
12668unsafe impl ::fidl_next::Wire for WireOptionalDictionaryRouterRouteResponse {
12669 type Decoded<'de> = WireOptionalDictionaryRouterRouteResponse;
12670
12671 #[inline]
12672 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12673 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12674 ::fidl_next::RawWireUnion::zero_padding(raw);
12675 }
12676}
12677
12678impl WireOptionalDictionaryRouterRouteResponse {
12679 pub fn is_some(&self) -> bool {
12680 self.raw.is_some()
12681 }
12682
12683 pub fn is_none(&self) -> bool {
12684 self.raw.is_none()
12685 }
12686
12687 pub fn as_ref(&self) -> ::core::option::Option<&WireDictionaryRouterRouteResponse> {
12688 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
12689 }
12690
12691 pub fn into_option(self) -> ::core::option::Option<WireDictionaryRouterRouteResponse> {
12692 if self.is_some() {
12693 Some(WireDictionaryRouterRouteResponse {
12694 raw: self.raw,
12695 _phantom: ::core::marker::PhantomData,
12696 })
12697 } else {
12698 None
12699 }
12700 }
12701}
12702
12703unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDictionaryRouterRouteResponse
12704where
12705 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12706 ___D: ::fidl_next::fuchsia::HandleDecoder,
12707{
12708 fn decode(
12709 mut slot: ::fidl_next::Slot<'_, Self>,
12710 decoder: &mut ___D,
12711 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12712 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12713 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12714 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDictionaryRef>(
12715 raw, decoder,
12716 )?,
12717
12718 2 => {
12719 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
12720 }
12721
12722 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
12723 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
12724 }
12725
12726 Ok(())
12727 }
12728}
12729
12730impl ::core::fmt::Debug for WireOptionalDictionaryRouterRouteResponse {
12731 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12732 self.as_ref().fmt(f)
12733 }
12734}
12735
12736#[derive(PartialEq, Debug)]
12738pub struct DictionaryRouter;
12739
12740impl ::fidl_next::Discoverable for DictionaryRouter {
12741 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
12742}
12743
12744pub mod dictionary_router {
12745 pub mod prelude {
12746 pub use crate::{
12747 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
12748 dictionary_router,
12749 };
12750
12751 pub use crate::DictionaryRouterRouteResponse;
12752
12753 pub use crate::RouteRequest;
12754
12755 pub use crate::RouterError;
12756 }
12757
12758 pub struct Route;
12759
12760 impl ::fidl_next::Method for Route {
12761 const ORDINAL: u64 = 8164012099375978399;
12762
12763 type Protocol = crate::DictionaryRouter;
12764
12765 type Request = crate::WireRouteRequest<'static>;
12766
12767 type Response = ::fidl_next::WireFlexibleResult<
12768 'static,
12769 crate::WireDictionaryRouterRouteResponse,
12770 crate::WireRouterError,
12771 >;
12772 }
12773
12774 mod ___detail {
12775
12776 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryRouter
12777 where
12778 ___T: ::fidl_next::Transport,
12779 {
12780 type Client = DictionaryRouterClient<___T>;
12781 type Server = DictionaryRouterServer<___T>;
12782 }
12783
12784 #[repr(transparent)]
12786 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
12787 #[allow(dead_code)]
12788 client: ::fidl_next::protocol::Client<___T>,
12789 }
12790
12791 impl<___T> DictionaryRouterClient<___T>
12792 where
12793 ___T: ::fidl_next::Transport,
12794 {
12795 pub fn route_with<___R>(
12796 &self,
12797 request: ___R,
12798 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12799 where
12800 ___R: ::fidl_next::Encode<
12801 <___T as ::fidl_next::Transport>::SendBuffer,
12802 Encoded = crate::WireRouteRequest<'static>,
12803 >,
12804 {
12805 ::fidl_next::TwoWayFuture::from_untyped(
12806 self.client.send_two_way(8164012099375978399, request),
12807 )
12808 }
12809 }
12810
12811 #[repr(transparent)]
12813 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
12814 server: ::fidl_next::protocol::Server<___T>,
12815 }
12816
12817 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12818 }
12819}
12820
12821pub trait DictionaryRouterClientHandler<
12825 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12826 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12827>
12828{
12829 fn on_unknown_interaction(
12830 &mut self,
12831 ordinal: u64,
12832 ) -> impl ::core::future::Future<
12833 Output = ::core::result::Result<
12834 (),
12835 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12836 >,
12837 > + ::core::marker::Send {
12838 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12839 }
12840}
12841
12842impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
12843where
12844 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
12845 ___T: ::fidl_next::Transport,
12846 <dictionary_router::Route as ::fidl_next::Method>::Response:
12847 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12848{
12849 async fn on_event(
12850 handler: &mut ___H,
12851 ordinal: u64,
12852 buffer: ___T::RecvBuffer,
12853 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12854 match ordinal {
12855 ordinal => handler.on_unknown_interaction(ordinal).await,
12856 }
12857 }
12858}
12859
12860pub trait DictionaryRouterServerHandler<
12864 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12865 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12866>
12867{
12868 fn route(
12869 &mut self,
12870
12871 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
12872
12873 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
12874 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12875
12876 fn on_unknown_interaction(
12877 &mut self,
12878 ordinal: u64,
12879 ) -> impl ::core::future::Future<
12880 Output = ::core::result::Result<
12881 (),
12882 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12883 >,
12884 > + ::core::marker::Send {
12885 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12886 }
12887}
12888
12889impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
12890where
12891 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
12892 ___T: ::fidl_next::Transport,
12893 <dictionary_router::Route as ::fidl_next::Method>::Request:
12894 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12895{
12896 async fn on_one_way(
12897 handler: &mut ___H,
12898 ordinal: u64,
12899 buffer: ___T::RecvBuffer,
12900 ) -> ::core::result::Result<
12901 (),
12902 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12903 > {
12904 match ordinal {
12905 ordinal => handler.on_unknown_interaction(ordinal).await,
12906 }
12907 }
12908
12909 async fn on_two_way(
12910 handler: &mut ___H,
12911 ordinal: u64,
12912 buffer: ___T::RecvBuffer,
12913 responder: ::fidl_next::protocol::Responder<___T>,
12914 ) -> ::core::result::Result<
12915 (),
12916 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12917 > {
12918 match ordinal {
12919 8164012099375978399 => {
12920 let responder = ::fidl_next::Responder::from_untyped(responder);
12921
12922 match ::fidl_next::DecoderExt::decode(buffer) {
12923 Ok(decoded) => {
12924 handler.route(decoded, responder).await;
12925 Ok(())
12926 }
12927 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12928 ordinal: 8164012099375978399,
12929 error,
12930 }),
12931 }
12932 }
12933
12934 ordinal => handler.on_unknown_interaction(ordinal).await,
12935 }
12936 }
12937}
12938
12939#[derive(PartialEq, Debug)]
12940pub enum DirConnectorRouterRouteResponse {
12941 DirConnector(crate::DirConnector),
12942
12943 Unavailable(crate::Unit),
12944}
12945
12946impl ::fidl_next::Encodable for DirConnectorRouterRouteResponse {
12947 type Encoded = WireDirConnectorRouterRouteResponse;
12948}
12949
12950unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnectorRouterRouteResponse
12951where
12952 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12953 ___E: ::fidl_next::fuchsia::HandleEncoder,
12954{
12955 #[inline]
12956 fn encode(
12957 self,
12958 encoder: &mut ___E,
12959 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12960 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12961 ::fidl_next::munge!(let WireDirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
12962
12963 match self {
12964 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12965 ___E,
12966 crate::DirConnector,
12967 >(value, 1, encoder, raw)?,
12968
12969 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12970 ___E,
12971 crate::Unit,
12972 >(value, 2, encoder, raw)?,
12973 }
12974
12975 Ok(())
12976 }
12977}
12978
12979impl ::fidl_next::EncodableOption for DirConnectorRouterRouteResponse {
12980 type EncodedOption = WireOptionalDirConnectorRouterRouteResponse;
12981}
12982
12983unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnectorRouterRouteResponse
12984where
12985 ___E: ?Sized,
12986 DirConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
12987{
12988 #[inline]
12989 fn encode_option(
12990 this: ::core::option::Option<Self>,
12991 encoder: &mut ___E,
12992 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12993 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12994 ::fidl_next::munge!(let WireOptionalDirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
12995
12996 if let Some(inner) = this {
12997 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
12998 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
12999 } else {
13000 ::fidl_next::RawWireUnion::encode_absent(raw);
13001 }
13002
13003 Ok(())
13004 }
13005}
13006
13007impl ::fidl_next::FromWire<WireDirConnectorRouterRouteResponse>
13008 for DirConnectorRouterRouteResponse
13009{
13010 #[inline]
13011 fn from_wire(wire: WireDirConnectorRouterRouteResponse) -> Self {
13012 let wire = ::core::mem::ManuallyDrop::new(wire);
13013 match wire.raw.ordinal() {
13014 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
13015 wire.raw.get().read_unchecked::<crate::WireDirConnector>()
13016 })),
13017
13018 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
13019 wire.raw.get().read_unchecked::<crate::WireUnit>()
13020 })),
13021
13022 _ => unsafe { ::core::hint::unreachable_unchecked() },
13023 }
13024 }
13025}
13026
13027impl ::fidl_next::IntoNatural for WireDirConnectorRouterRouteResponse {
13028 type Natural = DirConnectorRouterRouteResponse;
13029}
13030
13031impl ::fidl_next::FromWireOption<WireOptionalDirConnectorRouterRouteResponse>
13032 for DirConnectorRouterRouteResponse
13033{
13034 #[inline]
13035 fn from_wire_option(
13036 wire: WireOptionalDirConnectorRouterRouteResponse,
13037 ) -> ::core::option::Option<Self> {
13038 if let Some(inner) = wire.into_option() {
13039 Some(::fidl_next::FromWire::from_wire(inner))
13040 } else {
13041 None
13042 }
13043 }
13044}
13045
13046impl ::fidl_next::IntoNatural for WireOptionalDirConnectorRouterRouteResponse {
13047 type Natural = ::core::option::Option<DirConnectorRouterRouteResponse>;
13048}
13049
13050impl ::fidl_next::FromWireOption<WireOptionalDirConnectorRouterRouteResponse>
13051 for Box<DirConnectorRouterRouteResponse>
13052{
13053 #[inline]
13054 fn from_wire_option(
13055 wire: WireOptionalDirConnectorRouterRouteResponse,
13056 ) -> ::core::option::Option<Self> {
13057 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
13058 WireOptionalDirConnectorRouterRouteResponse,
13059 >>::from_wire_option(wire)
13060 .map(Box::new)
13061 }
13062}
13063
13064#[repr(transparent)]
13066pub struct WireDirConnectorRouterRouteResponse {
13067 raw: ::fidl_next::RawWireUnion,
13068 _phantom: ::core::marker::PhantomData<()>,
13069}
13070
13071impl Drop for WireDirConnectorRouterRouteResponse {
13072 fn drop(&mut self) {
13073 match self.raw.ordinal() {
13074 1 => {
13075 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirConnector>() };
13076 }
13077
13078 2 => {
13079 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
13080 }
13081
13082 _ => unsafe { ::core::hint::unreachable_unchecked() },
13083 }
13084 }
13085}
13086
13087unsafe impl ::fidl_next::Wire for WireDirConnectorRouterRouteResponse {
13088 type Decoded<'de> = WireDirConnectorRouterRouteResponse;
13089
13090 #[inline]
13091 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13092 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13093 ::fidl_next::RawWireUnion::zero_padding(raw);
13094 }
13095}
13096
13097pub mod dir_connector_router_route_response {
13098 pub enum Ref<'de> {
13099 DirConnector(&'de crate::WireDirConnector),
13100
13101 Unavailable(&'de crate::WireUnit),
13102 }
13103}
13104
13105impl WireDirConnectorRouterRouteResponse {
13106 pub fn as_ref(&self) -> crate::dir_connector_router_route_response::Ref<'_> {
13107 match self.raw.ordinal() {
13108 1 => crate::dir_connector_router_route_response::Ref::DirConnector(unsafe {
13109 self.raw.get().deref_unchecked::<crate::WireDirConnector>()
13110 }),
13111
13112 2 => crate::dir_connector_router_route_response::Ref::Unavailable(unsafe {
13113 self.raw.get().deref_unchecked::<crate::WireUnit>()
13114 }),
13115
13116 _ => unsafe { ::core::hint::unreachable_unchecked() },
13117 }
13118 }
13119}
13120
13121unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirConnectorRouterRouteResponse
13122where
13123 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13124 ___D: ::fidl_next::fuchsia::HandleDecoder,
13125{
13126 fn decode(
13127 mut slot: ::fidl_next::Slot<'_, Self>,
13128 decoder: &mut ___D,
13129 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13130 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13131 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13132 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirConnector>(
13133 raw, decoder,
13134 )?,
13135
13136 2 => {
13137 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13138 }
13139
13140 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13141 }
13142
13143 Ok(())
13144 }
13145}
13146
13147impl ::core::fmt::Debug for WireDirConnectorRouterRouteResponse {
13148 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13149 match self.raw.ordinal() {
13150 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirConnector>().fmt(f) },
13151 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
13152 _ => unsafe { ::core::hint::unreachable_unchecked() },
13153 }
13154 }
13155}
13156
13157#[repr(transparent)]
13158pub struct WireOptionalDirConnectorRouterRouteResponse {
13159 raw: ::fidl_next::RawWireUnion,
13160 _phantom: ::core::marker::PhantomData<()>,
13161}
13162
13163unsafe impl ::fidl_next::Wire for WireOptionalDirConnectorRouterRouteResponse {
13164 type Decoded<'de> = WireOptionalDirConnectorRouterRouteResponse;
13165
13166 #[inline]
13167 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13168 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13169 ::fidl_next::RawWireUnion::zero_padding(raw);
13170 }
13171}
13172
13173impl WireOptionalDirConnectorRouterRouteResponse {
13174 pub fn is_some(&self) -> bool {
13175 self.raw.is_some()
13176 }
13177
13178 pub fn is_none(&self) -> bool {
13179 self.raw.is_none()
13180 }
13181
13182 pub fn as_ref(&self) -> ::core::option::Option<&WireDirConnectorRouterRouteResponse> {
13183 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13184 }
13185
13186 pub fn into_option(self) -> ::core::option::Option<WireDirConnectorRouterRouteResponse> {
13187 if self.is_some() {
13188 Some(WireDirConnectorRouterRouteResponse {
13189 raw: self.raw,
13190 _phantom: ::core::marker::PhantomData,
13191 })
13192 } else {
13193 None
13194 }
13195 }
13196}
13197
13198unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirConnectorRouterRouteResponse
13199where
13200 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13201 ___D: ::fidl_next::fuchsia::HandleDecoder,
13202{
13203 fn decode(
13204 mut slot: ::fidl_next::Slot<'_, Self>,
13205 decoder: &mut ___D,
13206 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13207 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13208 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13209 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirConnector>(
13210 raw, decoder,
13211 )?,
13212
13213 2 => {
13214 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13215 }
13216
13217 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13218 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13219 }
13220
13221 Ok(())
13222 }
13223}
13224
13225impl ::core::fmt::Debug for WireOptionalDirConnectorRouterRouteResponse {
13226 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13227 self.as_ref().fmt(f)
13228 }
13229}
13230
13231#[derive(PartialEq, Debug)]
13233pub struct DirConnectorRouter;
13234
13235impl ::fidl_next::Discoverable for DirConnectorRouter {
13236 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
13237}
13238
13239pub mod dir_connector_router {
13240 pub mod prelude {
13241 pub use crate::{
13242 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
13243 dir_connector_router,
13244 };
13245
13246 pub use crate::DirConnectorRouterRouteResponse;
13247
13248 pub use crate::RouteRequest;
13249
13250 pub use crate::RouterError;
13251 }
13252
13253 pub struct Route;
13254
13255 impl ::fidl_next::Method for Route {
13256 const ORDINAL: u64 = 972231070188342848;
13257
13258 type Protocol = crate::DirConnectorRouter;
13259
13260 type Request = crate::WireRouteRequest<'static>;
13261
13262 type Response = ::fidl_next::WireFlexibleResult<
13263 'static,
13264 crate::WireDirConnectorRouterRouteResponse,
13265 crate::WireRouterError,
13266 >;
13267 }
13268
13269 mod ___detail {
13270
13271 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirConnectorRouter
13272 where
13273 ___T: ::fidl_next::Transport,
13274 {
13275 type Client = DirConnectorRouterClient<___T>;
13276 type Server = DirConnectorRouterServer<___T>;
13277 }
13278
13279 #[repr(transparent)]
13281 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
13282 #[allow(dead_code)]
13283 client: ::fidl_next::protocol::Client<___T>,
13284 }
13285
13286 impl<___T> DirConnectorRouterClient<___T>
13287 where
13288 ___T: ::fidl_next::Transport,
13289 {
13290 pub fn route_with<___R>(
13291 &self,
13292 request: ___R,
13293 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13294 where
13295 ___R: ::fidl_next::Encode<
13296 <___T as ::fidl_next::Transport>::SendBuffer,
13297 Encoded = crate::WireRouteRequest<'static>,
13298 >,
13299 {
13300 ::fidl_next::TwoWayFuture::from_untyped(
13301 self.client.send_two_way(972231070188342848, request),
13302 )
13303 }
13304 }
13305
13306 #[repr(transparent)]
13308 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
13309 server: ::fidl_next::protocol::Server<___T>,
13310 }
13311
13312 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
13313 }
13314}
13315
13316pub trait DirConnectorRouterClientHandler<
13320 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13321 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13322>
13323{
13324 fn on_unknown_interaction(
13325 &mut self,
13326 ordinal: u64,
13327 ) -> impl ::core::future::Future<
13328 Output = ::core::result::Result<
13329 (),
13330 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13331 >,
13332 > + ::core::marker::Send {
13333 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13334 }
13335}
13336
13337impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
13338where
13339 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
13340 ___T: ::fidl_next::Transport,
13341 <dir_connector_router::Route as ::fidl_next::Method>::Response:
13342 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13343{
13344 async fn on_event(
13345 handler: &mut ___H,
13346 ordinal: u64,
13347 buffer: ___T::RecvBuffer,
13348 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13349 match ordinal {
13350 ordinal => handler.on_unknown_interaction(ordinal).await,
13351 }
13352 }
13353}
13354
13355pub trait DirConnectorRouterServerHandler<
13359 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13360 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13361>
13362{
13363 fn route(
13364 &mut self,
13365
13366 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
13367
13368 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
13369 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13370
13371 fn on_unknown_interaction(
13372 &mut self,
13373 ordinal: u64,
13374 ) -> impl ::core::future::Future<
13375 Output = ::core::result::Result<
13376 (),
13377 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13378 >,
13379 > + ::core::marker::Send {
13380 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13381 }
13382}
13383
13384impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
13385where
13386 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
13387 ___T: ::fidl_next::Transport,
13388 <dir_connector_router::Route as ::fidl_next::Method>::Request:
13389 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13390{
13391 async fn on_one_way(
13392 handler: &mut ___H,
13393 ordinal: u64,
13394 buffer: ___T::RecvBuffer,
13395 ) -> ::core::result::Result<
13396 (),
13397 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13398 > {
13399 match ordinal {
13400 ordinal => handler.on_unknown_interaction(ordinal).await,
13401 }
13402 }
13403
13404 async fn on_two_way(
13405 handler: &mut ___H,
13406 ordinal: u64,
13407 buffer: ___T::RecvBuffer,
13408 responder: ::fidl_next::protocol::Responder<___T>,
13409 ) -> ::core::result::Result<
13410 (),
13411 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13412 > {
13413 match ordinal {
13414 972231070188342848 => {
13415 let responder = ::fidl_next::Responder::from_untyped(responder);
13416
13417 match ::fidl_next::DecoderExt::decode(buffer) {
13418 Ok(decoded) => {
13419 handler.route(decoded, responder).await;
13420 Ok(())
13421 }
13422 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13423 ordinal: 972231070188342848,
13424 error,
13425 }),
13426 }
13427 }
13428
13429 ordinal => handler.on_unknown_interaction(ordinal).await,
13430 }
13431 }
13432}
13433
13434#[derive(PartialEq, Debug)]
13435pub enum DirEntryRouterRouteResponse {
13436 DirEntry(crate::DirEntry),
13437
13438 Unavailable(crate::Unit),
13439}
13440
13441impl ::fidl_next::Encodable for DirEntryRouterRouteResponse {
13442 type Encoded = WireDirEntryRouterRouteResponse;
13443}
13444
13445unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntryRouterRouteResponse
13446where
13447 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
13448 ___E: ::fidl_next::fuchsia::HandleEncoder,
13449{
13450 #[inline]
13451 fn encode(
13452 self,
13453 encoder: &mut ___E,
13454 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
13455 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13456 ::fidl_next::munge!(let WireDirEntryRouterRouteResponse { raw, _phantom: _ } = out);
13457
13458 match self {
13459 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
13460 ___E,
13461 crate::DirEntry,
13462 >(value, 1, encoder, raw)?,
13463
13464 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
13465 ___E,
13466 crate::Unit,
13467 >(value, 2, encoder, raw)?,
13468 }
13469
13470 Ok(())
13471 }
13472}
13473
13474impl ::fidl_next::EncodableOption for DirEntryRouterRouteResponse {
13475 type EncodedOption = WireOptionalDirEntryRouterRouteResponse;
13476}
13477
13478unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntryRouterRouteResponse
13479where
13480 ___E: ?Sized,
13481 DirEntryRouterRouteResponse: ::fidl_next::Encode<___E>,
13482{
13483 #[inline]
13484 fn encode_option(
13485 this: ::core::option::Option<Self>,
13486 encoder: &mut ___E,
13487 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
13488 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13489 ::fidl_next::munge!(let WireOptionalDirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
13490
13491 if let Some(inner) = this {
13492 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
13493 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
13494 } else {
13495 ::fidl_next::RawWireUnion::encode_absent(raw);
13496 }
13497
13498 Ok(())
13499 }
13500}
13501
13502impl ::fidl_next::FromWire<WireDirEntryRouterRouteResponse> for DirEntryRouterRouteResponse {
13503 #[inline]
13504 fn from_wire(wire: WireDirEntryRouterRouteResponse) -> Self {
13505 let wire = ::core::mem::ManuallyDrop::new(wire);
13506 match wire.raw.ordinal() {
13507 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
13508 wire.raw.get().read_unchecked::<crate::WireDirEntry>()
13509 })),
13510
13511 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
13512 wire.raw.get().read_unchecked::<crate::WireUnit>()
13513 })),
13514
13515 _ => unsafe { ::core::hint::unreachable_unchecked() },
13516 }
13517 }
13518}
13519
13520impl ::fidl_next::IntoNatural for WireDirEntryRouterRouteResponse {
13521 type Natural = DirEntryRouterRouteResponse;
13522}
13523
13524impl ::fidl_next::FromWireOption<WireOptionalDirEntryRouterRouteResponse>
13525 for DirEntryRouterRouteResponse
13526{
13527 #[inline]
13528 fn from_wire_option(
13529 wire: WireOptionalDirEntryRouterRouteResponse,
13530 ) -> ::core::option::Option<Self> {
13531 if let Some(inner) = wire.into_option() {
13532 Some(::fidl_next::FromWire::from_wire(inner))
13533 } else {
13534 None
13535 }
13536 }
13537}
13538
13539impl ::fidl_next::IntoNatural for WireOptionalDirEntryRouterRouteResponse {
13540 type Natural = ::core::option::Option<DirEntryRouterRouteResponse>;
13541}
13542
13543impl ::fidl_next::FromWireOption<WireOptionalDirEntryRouterRouteResponse>
13544 for Box<DirEntryRouterRouteResponse>
13545{
13546 #[inline]
13547 fn from_wire_option(
13548 wire: WireOptionalDirEntryRouterRouteResponse,
13549 ) -> ::core::option::Option<Self> {
13550 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
13551 WireOptionalDirEntryRouterRouteResponse,
13552 >>::from_wire_option(wire)
13553 .map(Box::new)
13554 }
13555}
13556
13557#[repr(transparent)]
13559pub struct WireDirEntryRouterRouteResponse {
13560 raw: ::fidl_next::RawWireUnion,
13561 _phantom: ::core::marker::PhantomData<()>,
13562}
13563
13564impl Drop for WireDirEntryRouterRouteResponse {
13565 fn drop(&mut self) {
13566 match self.raw.ordinal() {
13567 1 => {
13568 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirEntry>() };
13569 }
13570
13571 2 => {
13572 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
13573 }
13574
13575 _ => unsafe { ::core::hint::unreachable_unchecked() },
13576 }
13577 }
13578}
13579
13580unsafe impl ::fidl_next::Wire for WireDirEntryRouterRouteResponse {
13581 type Decoded<'de> = WireDirEntryRouterRouteResponse;
13582
13583 #[inline]
13584 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13585 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13586 ::fidl_next::RawWireUnion::zero_padding(raw);
13587 }
13588}
13589
13590pub mod dir_entry_router_route_response {
13591 pub enum Ref<'de> {
13592 DirEntry(&'de crate::WireDirEntry),
13593
13594 Unavailable(&'de crate::WireUnit),
13595 }
13596}
13597
13598impl WireDirEntryRouterRouteResponse {
13599 pub fn as_ref(&self) -> crate::dir_entry_router_route_response::Ref<'_> {
13600 match self.raw.ordinal() {
13601 1 => crate::dir_entry_router_route_response::Ref::DirEntry(unsafe {
13602 self.raw.get().deref_unchecked::<crate::WireDirEntry>()
13603 }),
13604
13605 2 => crate::dir_entry_router_route_response::Ref::Unavailable(unsafe {
13606 self.raw.get().deref_unchecked::<crate::WireUnit>()
13607 }),
13608
13609 _ => unsafe { ::core::hint::unreachable_unchecked() },
13610 }
13611 }
13612}
13613
13614unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirEntryRouterRouteResponse
13615where
13616 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13617 ___D: ::fidl_next::fuchsia::HandleDecoder,
13618{
13619 fn decode(
13620 mut slot: ::fidl_next::Slot<'_, Self>,
13621 decoder: &mut ___D,
13622 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13623 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13624 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13625 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirEntry>(
13626 raw, decoder,
13627 )?,
13628
13629 2 => {
13630 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13631 }
13632
13633 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13634 }
13635
13636 Ok(())
13637 }
13638}
13639
13640impl ::core::fmt::Debug for WireDirEntryRouterRouteResponse {
13641 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13642 match self.raw.ordinal() {
13643 1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
13644 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
13645 _ => unsafe { ::core::hint::unreachable_unchecked() },
13646 }
13647 }
13648}
13649
13650#[repr(transparent)]
13651pub struct WireOptionalDirEntryRouterRouteResponse {
13652 raw: ::fidl_next::RawWireUnion,
13653 _phantom: ::core::marker::PhantomData<()>,
13654}
13655
13656unsafe impl ::fidl_next::Wire for WireOptionalDirEntryRouterRouteResponse {
13657 type Decoded<'de> = WireOptionalDirEntryRouterRouteResponse;
13658
13659 #[inline]
13660 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13661 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13662 ::fidl_next::RawWireUnion::zero_padding(raw);
13663 }
13664}
13665
13666impl WireOptionalDirEntryRouterRouteResponse {
13667 pub fn is_some(&self) -> bool {
13668 self.raw.is_some()
13669 }
13670
13671 pub fn is_none(&self) -> bool {
13672 self.raw.is_none()
13673 }
13674
13675 pub fn as_ref(&self) -> ::core::option::Option<&WireDirEntryRouterRouteResponse> {
13676 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13677 }
13678
13679 pub fn into_option(self) -> ::core::option::Option<WireDirEntryRouterRouteResponse> {
13680 if self.is_some() {
13681 Some(WireDirEntryRouterRouteResponse {
13682 raw: self.raw,
13683 _phantom: ::core::marker::PhantomData,
13684 })
13685 } else {
13686 None
13687 }
13688 }
13689}
13690
13691unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirEntryRouterRouteResponse
13692where
13693 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13694 ___D: ::fidl_next::fuchsia::HandleDecoder,
13695{
13696 fn decode(
13697 mut slot: ::fidl_next::Slot<'_, Self>,
13698 decoder: &mut ___D,
13699 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13700 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13701 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13702 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirEntry>(
13703 raw, decoder,
13704 )?,
13705
13706 2 => {
13707 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13708 }
13709
13710 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13711 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13712 }
13713
13714 Ok(())
13715 }
13716}
13717
13718impl ::core::fmt::Debug for WireOptionalDirEntryRouterRouteResponse {
13719 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13720 self.as_ref().fmt(f)
13721 }
13722}
13723
13724#[derive(PartialEq, Debug)]
13726pub struct DirEntryRouter;
13727
13728impl ::fidl_next::Discoverable for DirEntryRouter {
13729 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
13730}
13731
13732pub mod dir_entry_router {
13733 pub mod prelude {
13734 pub use crate::{
13735 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
13736 dir_entry_router,
13737 };
13738
13739 pub use crate::DirEntryRouterRouteResponse;
13740
13741 pub use crate::RouteRequest;
13742
13743 pub use crate::RouterError;
13744 }
13745
13746 pub struct Route;
13747
13748 impl ::fidl_next::Method for Route {
13749 const ORDINAL: u64 = 1929392218567642066;
13750
13751 type Protocol = crate::DirEntryRouter;
13752
13753 type Request = crate::WireRouteRequest<'static>;
13754
13755 type Response = ::fidl_next::WireFlexibleResult<
13756 'static,
13757 crate::WireDirEntryRouterRouteResponse,
13758 crate::WireRouterError,
13759 >;
13760 }
13761
13762 mod ___detail {
13763
13764 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirEntryRouter
13765 where
13766 ___T: ::fidl_next::Transport,
13767 {
13768 type Client = DirEntryRouterClient<___T>;
13769 type Server = DirEntryRouterServer<___T>;
13770 }
13771
13772 #[repr(transparent)]
13774 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
13775 #[allow(dead_code)]
13776 client: ::fidl_next::protocol::Client<___T>,
13777 }
13778
13779 impl<___T> DirEntryRouterClient<___T>
13780 where
13781 ___T: ::fidl_next::Transport,
13782 {
13783 pub fn route_with<___R>(
13784 &self,
13785 request: ___R,
13786 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13787 where
13788 ___R: ::fidl_next::Encode<
13789 <___T as ::fidl_next::Transport>::SendBuffer,
13790 Encoded = crate::WireRouteRequest<'static>,
13791 >,
13792 {
13793 ::fidl_next::TwoWayFuture::from_untyped(
13794 self.client.send_two_way(1929392218567642066, request),
13795 )
13796 }
13797 }
13798
13799 #[repr(transparent)]
13801 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
13802 server: ::fidl_next::protocol::Server<___T>,
13803 }
13804
13805 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
13806 }
13807}
13808
13809pub trait DirEntryRouterClientHandler<
13813 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13814 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13815>
13816{
13817 fn on_unknown_interaction(
13818 &mut self,
13819 ordinal: u64,
13820 ) -> impl ::core::future::Future<
13821 Output = ::core::result::Result<
13822 (),
13823 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13824 >,
13825 > + ::core::marker::Send {
13826 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13827 }
13828}
13829
13830impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
13831where
13832 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
13833 ___T: ::fidl_next::Transport,
13834 <dir_entry_router::Route as ::fidl_next::Method>::Response:
13835 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13836{
13837 async fn on_event(
13838 handler: &mut ___H,
13839 ordinal: u64,
13840 buffer: ___T::RecvBuffer,
13841 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13842 match ordinal {
13843 ordinal => handler.on_unknown_interaction(ordinal).await,
13844 }
13845 }
13846}
13847
13848pub trait DirEntryRouterServerHandler<
13852 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13853 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13854>
13855{
13856 fn route(
13857 &mut self,
13858
13859 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
13860
13861 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
13862 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13863
13864 fn on_unknown_interaction(
13865 &mut self,
13866 ordinal: u64,
13867 ) -> impl ::core::future::Future<
13868 Output = ::core::result::Result<
13869 (),
13870 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13871 >,
13872 > + ::core::marker::Send {
13873 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13874 }
13875}
13876
13877impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
13878where
13879 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
13880 ___T: ::fidl_next::Transport,
13881 <dir_entry_router::Route as ::fidl_next::Method>::Request:
13882 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13883{
13884 async fn on_one_way(
13885 handler: &mut ___H,
13886 ordinal: u64,
13887 buffer: ___T::RecvBuffer,
13888 ) -> ::core::result::Result<
13889 (),
13890 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13891 > {
13892 match ordinal {
13893 ordinal => handler.on_unknown_interaction(ordinal).await,
13894 }
13895 }
13896
13897 async fn on_two_way(
13898 handler: &mut ___H,
13899 ordinal: u64,
13900 buffer: ___T::RecvBuffer,
13901 responder: ::fidl_next::protocol::Responder<___T>,
13902 ) -> ::core::result::Result<
13903 (),
13904 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13905 > {
13906 match ordinal {
13907 1929392218567642066 => {
13908 let responder = ::fidl_next::Responder::from_untyped(responder);
13909
13910 match ::fidl_next::DecoderExt::decode(buffer) {
13911 Ok(decoded) => {
13912 handler.route(decoded, responder).await;
13913 Ok(())
13914 }
13915 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13916 ordinal: 1929392218567642066,
13917 error,
13918 }),
13919 }
13920 }
13921
13922 ordinal => handler.on_unknown_interaction(ordinal).await,
13923 }
13924 }
13925}
13926
13927#[derive(PartialEq, Debug)]
13928#[repr(C)]
13929pub struct DirReceiverReceiveRequest {
13930 pub channel: ::fidl_next::ServerEnd<
13931 ::fidl_next_fuchsia_io::Directory,
13932 ::fidl_next::fuchsia::zx::Channel,
13933 >,
13934}
13935
13936impl ::fidl_next::Encodable for DirReceiverReceiveRequest {
13937 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirReceiverReceiveRequest> = unsafe {
13938 ::fidl_next::CopyOptimization::enable_if(
13939 true && <::fidl_next::ServerEnd<
13940 ::fidl_next_fuchsia_io::Directory,
13941 ::fidl_next::fuchsia::zx::Channel,
13942 > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
13943 .is_enabled(),
13944 )
13945 };
13946
13947 type Encoded = WireDirReceiverReceiveRequest;
13948}
13949
13950unsafe impl<___E> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest
13951where
13952 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
13953 ___E: ::fidl_next::fuchsia::HandleEncoder,
13954{
13955 #[inline]
13956 fn encode(
13957 self,
13958 encoder_: &mut ___E,
13959 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
13960 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13961 ::fidl_next::munge! {
13962 let Self::Encoded {
13963 channel,
13964
13965 } = out_;
13966 }
13967
13968 ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
13969
13970 Ok(())
13971 }
13972}
13973
13974impl ::fidl_next::EncodableOption for DirReceiverReceiveRequest {
13975 type EncodedOption = ::fidl_next::WireBox<'static, WireDirReceiverReceiveRequest>;
13976}
13977
13978unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirReceiverReceiveRequest
13979where
13980 ___E: ::fidl_next::Encoder + ?Sized,
13981 DirReceiverReceiveRequest: ::fidl_next::Encode<___E>,
13982{
13983 #[inline]
13984 fn encode_option(
13985 this: ::core::option::Option<Self>,
13986 encoder: &mut ___E,
13987 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
13988 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13989 if let Some(inner) = this {
13990 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
13991 ::fidl_next::WireBox::encode_present(out);
13992 } else {
13993 ::fidl_next::WireBox::encode_absent(out);
13994 }
13995
13996 Ok(())
13997 }
13998}
13999
14000impl ::fidl_next::FromWire<WireDirReceiverReceiveRequest> for DirReceiverReceiveRequest {
14001 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirReceiverReceiveRequest, Self> = unsafe {
14002 ::fidl_next::CopyOptimization::enable_if(
14003 true && <::fidl_next::ServerEnd<
14004 ::fidl_next_fuchsia_io::Directory,
14005 ::fidl_next::fuchsia::zx::Channel,
14006 > as ::fidl_next::FromWire<
14007 ::fidl_next::ServerEnd<
14008 ::fidl_next_fuchsia_io::Directory,
14009 ::fidl_next::fuchsia::WireChannel,
14010 >,
14011 >>::COPY_OPTIMIZATION
14012 .is_enabled(),
14013 )
14014 };
14015
14016 #[inline]
14017 fn from_wire(wire: WireDirReceiverReceiveRequest) -> Self {
14018 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
14019 }
14020}
14021
14022impl ::fidl_next::IntoNatural for WireDirReceiverReceiveRequest {
14023 type Natural = DirReceiverReceiveRequest;
14024}
14025
14026#[derive(Debug)]
14028#[repr(C)]
14029pub struct WireDirReceiverReceiveRequest {
14030 pub channel: ::fidl_next::ServerEnd<
14031 ::fidl_next_fuchsia_io::Directory,
14032 ::fidl_next::fuchsia::WireChannel,
14033 >,
14034}
14035static_assertions::const_assert_eq!(std::mem::size_of::<WireDirReceiverReceiveRequest>(), 4);
14036static_assertions::const_assert_eq!(std::mem::align_of::<WireDirReceiverReceiveRequest>(), 4);
14037
14038static_assertions::const_assert_eq!(
14039 std::mem::offset_of!(WireDirReceiverReceiveRequest, channel),
14040 0
14041);
14042
14043unsafe impl ::fidl_next::Wire for WireDirReceiverReceiveRequest {
14044 type Decoded<'de> = WireDirReceiverReceiveRequest;
14045
14046 #[inline]
14047 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14048 ::fidl_next::munge! {
14049 let Self {
14050
14051 channel,
14052
14053 } = &mut *out_;
14054 }
14055
14056 ::fidl_next::Wire::zero_padding(channel);
14057 }
14058}
14059
14060unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirReceiverReceiveRequest
14061where
14062 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14063 ___D: ::fidl_next::fuchsia::HandleDecoder,
14064{
14065 fn decode(
14066 slot_: ::fidl_next::Slot<'_, Self>,
14067 decoder_: &mut ___D,
14068 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14069 ::fidl_next::munge! {
14070 let Self {
14071
14072 mut channel,
14073
14074 } = slot_;
14075 }
14076
14077 ::fidl_next::Decode::decode(channel.as_mut(), decoder_)?;
14078
14079 Ok(())
14080 }
14081}
14082
14083#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
14085#[derive(PartialEq, Debug)]
14086pub struct DirReceiver;
14087
14088impl ::fidl_next::Discoverable for DirReceiver {
14089 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
14090}
14091
14092pub mod dir_receiver {
14093 pub mod prelude {
14094 pub use crate::{
14095 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
14096 };
14097
14098 pub use crate::DirReceiverReceiveRequest;
14099 }
14100
14101 pub struct Receive;
14102
14103 impl ::fidl_next::Method for Receive {
14104 const ORDINAL: u64 = 926684461087488948;
14105
14106 type Protocol = crate::DirReceiver;
14107
14108 type Request = crate::WireDirReceiverReceiveRequest;
14109
14110 type Response = ::fidl_next::Never;
14111 }
14112
14113 mod ___detail {
14114
14115 pub struct Receive<T0> {
14116 channel: T0,
14117 }
14118
14119 impl<T0> ::fidl_next::Encodable for Receive<T0>
14120 where
14121 T0: ::fidl_next::Encodable<
14122 Encoded = ::fidl_next::ServerEnd<
14123 ::fidl_next_fuchsia_io::Directory,
14124 ::fidl_next::fuchsia::WireChannel,
14125 >,
14126 >,
14127 {
14128 type Encoded = crate::WireDirReceiverReceiveRequest;
14129 }
14130
14131 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Receive<T0>
14132 where
14133 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14134 ___E: ::fidl_next::fuchsia::HandleEncoder,
14135 T0: ::fidl_next::Encode<
14136 ___E,
14137 Encoded = ::fidl_next::ServerEnd<
14138 ::fidl_next_fuchsia_io::Directory,
14139 ::fidl_next::fuchsia::WireChannel,
14140 >,
14141 >,
14142 {
14143 #[inline]
14144 fn encode(
14145 self,
14146 encoder_: &mut ___E,
14147 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14148 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14149 ::fidl_next::munge! {
14150 let Self::Encoded {
14151 channel,
14152
14153 } = out_;
14154 }
14155
14156 ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
14157
14158 Ok(())
14159 }
14160 }
14161
14162 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirReceiver
14163 where
14164 ___T: ::fidl_next::Transport,
14165 {
14166 type Client = DirReceiverClient<___T>;
14167 type Server = DirReceiverServer<___T>;
14168 }
14169
14170 #[repr(transparent)]
14172 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
14173 #[allow(dead_code)]
14174 client: ::fidl_next::protocol::Client<___T>,
14175 }
14176
14177 impl<___T> DirReceiverClient<___T>
14178 where
14179 ___T: ::fidl_next::Transport,
14180 {
14181 #[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"]
14182 pub fn receive(
14183 &self,
14184
14185 channel: impl ::fidl_next::Encode<
14186 <___T as ::fidl_next::Transport>::SendBuffer,
14187 Encoded = ::fidl_next::ServerEnd<
14188 ::fidl_next_fuchsia_io::Directory,
14189 ::fidl_next::fuchsia::WireChannel,
14190 >,
14191 >,
14192 ) -> ::fidl_next::SendFuture<'_, ___T>
14193 where
14194 <___T as ::fidl_next::Transport>::SendBuffer:
14195 ::fidl_next::encoder::InternalHandleEncoder,
14196 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14197 {
14198 self.receive_with(Receive { channel })
14199 }
14200
14201 #[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"]
14202 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14203 where
14204 ___R: ::fidl_next::Encode<
14205 <___T as ::fidl_next::Transport>::SendBuffer,
14206 Encoded = crate::WireDirReceiverReceiveRequest,
14207 >,
14208 {
14209 ::fidl_next::SendFuture::from_untyped(
14210 self.client.send_one_way(926684461087488948, request),
14211 )
14212 }
14213 }
14214
14215 #[repr(transparent)]
14217 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
14218 server: ::fidl_next::protocol::Server<___T>,
14219 }
14220
14221 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
14222 }
14223}
14224
14225pub trait DirReceiverClientHandler<
14229 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14230 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14231>
14232{
14233 fn on_unknown_interaction(
14234 &mut self,
14235 ordinal: u64,
14236 ) -> impl ::core::future::Future<
14237 Output = ::core::result::Result<
14238 (),
14239 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14240 >,
14241 > + ::core::marker::Send {
14242 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14243 }
14244}
14245
14246impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
14247where
14248 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
14249 ___T: ::fidl_next::Transport,
14250{
14251 async fn on_event(
14252 handler: &mut ___H,
14253 ordinal: u64,
14254 buffer: ___T::RecvBuffer,
14255 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14256 match ordinal {
14257 ordinal => handler.on_unknown_interaction(ordinal).await,
14258 }
14259 }
14260}
14261
14262pub trait DirReceiverServerHandler<
14266 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14267 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14268>
14269{
14270 #[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"]
14271 fn receive(
14272 &mut self,
14273
14274 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
14275 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14276
14277 fn on_unknown_interaction(
14278 &mut self,
14279 ordinal: u64,
14280 ) -> impl ::core::future::Future<
14281 Output = ::core::result::Result<
14282 (),
14283 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14284 >,
14285 > + ::core::marker::Send {
14286 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14287 }
14288}
14289
14290impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
14291where
14292 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
14293 ___T: ::fidl_next::Transport,
14294 <dir_receiver::Receive as ::fidl_next::Method>::Request:
14295 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14296{
14297 async fn on_one_way(
14298 handler: &mut ___H,
14299 ordinal: u64,
14300 buffer: ___T::RecvBuffer,
14301 ) -> ::core::result::Result<
14302 (),
14303 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14304 > {
14305 match ordinal {
14306 926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
14307 Ok(decoded) => {
14308 handler.receive(decoded).await;
14309 Ok(())
14310 }
14311 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14312 ordinal: 926684461087488948,
14313 error,
14314 }),
14315 },
14316
14317 ordinal => handler.on_unknown_interaction(ordinal).await,
14318 }
14319 }
14320
14321 async fn on_two_way(
14322 handler: &mut ___H,
14323 ordinal: u64,
14324 buffer: ___T::RecvBuffer,
14325 responder: ::fidl_next::protocol::Responder<___T>,
14326 ) -> ::core::result::Result<
14327 (),
14328 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14329 > {
14330 match ordinal {
14331 ordinal => handler.on_unknown_interaction(ordinal).await,
14332 }
14333 }
14334}
14335
14336#[derive(PartialEq, Debug)]
14337pub enum DirectoryRouterRouteResponse {
14338 Directory(
14339 ::fidl_next::ClientEnd<
14340 ::fidl_next_fuchsia_io::Directory,
14341 ::fidl_next::fuchsia::zx::Channel,
14342 >,
14343 ),
14344
14345 Unavailable(crate::Unit),
14346}
14347
14348impl ::fidl_next::Encodable for DirectoryRouterRouteResponse {
14349 type Encoded = WireDirectoryRouterRouteResponse;
14350}
14351
14352unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRouterRouteResponse
14353where
14354 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14355 ___E: ::fidl_next::fuchsia::HandleEncoder,
14356{
14357 #[inline]
14358 fn encode(
14359 self,
14360 encoder: &mut ___E,
14361 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14362 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14363 ::fidl_next::munge!(let WireDirectoryRouterRouteResponse { raw, _phantom: _ } = out);
14364
14365 match self {
14366 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
14367 ___E,
14368 ::fidl_next::ClientEnd<
14369 ::fidl_next_fuchsia_io::Directory,
14370 ::fidl_next::fuchsia::zx::Channel,
14371 >,
14372 >(value, 1, encoder, raw)?,
14373
14374 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
14375 ___E,
14376 crate::Unit,
14377 >(value, 2, encoder, raw)?,
14378 }
14379
14380 Ok(())
14381 }
14382}
14383
14384impl ::fidl_next::EncodableOption for DirectoryRouterRouteResponse {
14385 type EncodedOption = WireOptionalDirectoryRouterRouteResponse;
14386}
14387
14388unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRouterRouteResponse
14389where
14390 ___E: ?Sized,
14391 DirectoryRouterRouteResponse: ::fidl_next::Encode<___E>,
14392{
14393 #[inline]
14394 fn encode_option(
14395 this: ::core::option::Option<Self>,
14396 encoder: &mut ___E,
14397 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
14398 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14399 ::fidl_next::munge!(let WireOptionalDirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
14400
14401 if let Some(inner) = this {
14402 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
14403 ::fidl_next::Encode::encode(inner, encoder, value_out)?;
14404 } else {
14405 ::fidl_next::RawWireUnion::encode_absent(raw);
14406 }
14407
14408 Ok(())
14409 }
14410}
14411
14412impl ::fidl_next::FromWire<WireDirectoryRouterRouteResponse> for DirectoryRouterRouteResponse {
14413 #[inline]
14414 fn from_wire(wire: WireDirectoryRouterRouteResponse) -> Self {
14415 let wire = ::core::mem::ManuallyDrop::new(wire);
14416 match wire.raw.ordinal() {
14417 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
14418 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
14419 ::fidl_next_fuchsia_io::Directory,
14420 ::fidl_next::fuchsia::WireChannel,
14421 >>()
14422 })),
14423
14424 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
14425 wire.raw.get().read_unchecked::<crate::WireUnit>()
14426 })),
14427
14428 _ => unsafe { ::core::hint::unreachable_unchecked() },
14429 }
14430 }
14431}
14432
14433impl ::fidl_next::IntoNatural for WireDirectoryRouterRouteResponse {
14434 type Natural = DirectoryRouterRouteResponse;
14435}
14436
14437impl ::fidl_next::FromWireOption<WireOptionalDirectoryRouterRouteResponse>
14438 for DirectoryRouterRouteResponse
14439{
14440 #[inline]
14441 fn from_wire_option(
14442 wire: WireOptionalDirectoryRouterRouteResponse,
14443 ) -> ::core::option::Option<Self> {
14444 if let Some(inner) = wire.into_option() {
14445 Some(::fidl_next::FromWire::from_wire(inner))
14446 } else {
14447 None
14448 }
14449 }
14450}
14451
14452impl ::fidl_next::IntoNatural for WireOptionalDirectoryRouterRouteResponse {
14453 type Natural = ::core::option::Option<DirectoryRouterRouteResponse>;
14454}
14455
14456impl ::fidl_next::FromWireOption<WireOptionalDirectoryRouterRouteResponse>
14457 for Box<DirectoryRouterRouteResponse>
14458{
14459 #[inline]
14460 fn from_wire_option(
14461 wire: WireOptionalDirectoryRouterRouteResponse,
14462 ) -> ::core::option::Option<Self> {
14463 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
14464 WireOptionalDirectoryRouterRouteResponse,
14465 >>::from_wire_option(wire)
14466 .map(Box::new)
14467 }
14468}
14469
14470#[repr(transparent)]
14472pub struct WireDirectoryRouterRouteResponse {
14473 raw: ::fidl_next::RawWireUnion,
14474 _phantom: ::core::marker::PhantomData<()>,
14475}
14476
14477impl Drop for WireDirectoryRouterRouteResponse {
14478 fn drop(&mut self) {
14479 match self.raw.ordinal() {
14480 1 => {
14481 let _ = unsafe {
14482 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
14483 ::fidl_next_fuchsia_io::Directory,
14484 ::fidl_next::fuchsia::WireChannel,
14485 >>()
14486 };
14487 }
14488
14489 2 => {
14490 let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
14491 }
14492
14493 _ => unsafe { ::core::hint::unreachable_unchecked() },
14494 }
14495 }
14496}
14497
14498unsafe impl ::fidl_next::Wire for WireDirectoryRouterRouteResponse {
14499 type Decoded<'de> = WireDirectoryRouterRouteResponse;
14500
14501 #[inline]
14502 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14503 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14504 ::fidl_next::RawWireUnion::zero_padding(raw);
14505 }
14506}
14507
14508pub mod directory_router_route_response {
14509 pub enum Ref<'de> {
14510 Directory(
14511 &'de ::fidl_next::ClientEnd<
14512 ::fidl_next_fuchsia_io::Directory,
14513 ::fidl_next::fuchsia::WireChannel,
14514 >,
14515 ),
14516
14517 Unavailable(&'de crate::WireUnit),
14518 }
14519}
14520
14521impl WireDirectoryRouterRouteResponse {
14522 pub fn as_ref(&self) -> crate::directory_router_route_response::Ref<'_> {
14523 match self.raw.ordinal() {
14524 1 => crate::directory_router_route_response::Ref::Directory(unsafe {
14525 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
14526 ::fidl_next_fuchsia_io::Directory,
14527 ::fidl_next::fuchsia::WireChannel,
14528 >>()
14529 }),
14530
14531 2 => crate::directory_router_route_response::Ref::Unavailable(unsafe {
14532 self.raw.get().deref_unchecked::<crate::WireUnit>()
14533 }),
14534
14535 _ => unsafe { ::core::hint::unreachable_unchecked() },
14536 }
14537 }
14538}
14539
14540unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryRouterRouteResponse
14541where
14542 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14543 ___D: ::fidl_next::fuchsia::HandleDecoder,
14544{
14545 fn decode(
14546 mut slot: ::fidl_next::Slot<'_, Self>,
14547 decoder: &mut ___D,
14548 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14549 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14550 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14551 1 => ::fidl_next::RawWireUnion::decode_as_static::<
14552 ___D,
14553 ::fidl_next::ClientEnd<
14554 ::fidl_next_fuchsia_io::Directory,
14555 ::fidl_next::fuchsia::WireChannel,
14556 >,
14557 >(raw, decoder)?,
14558
14559 2 => {
14560 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
14561 }
14562
14563 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
14564 }
14565
14566 Ok(())
14567 }
14568}
14569
14570impl ::core::fmt::Debug for WireDirectoryRouterRouteResponse {
14571 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14572 match self.raw.ordinal() {
14573 1 => unsafe {
14574 self.raw
14575 .get()
14576 .deref_unchecked::<::fidl_next::ClientEnd<
14577 ::fidl_next_fuchsia_io::Directory,
14578 ::fidl_next::fuchsia::WireChannel,
14579 >>()
14580 .fmt(f)
14581 },
14582 2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
14583 _ => unsafe { ::core::hint::unreachable_unchecked() },
14584 }
14585 }
14586}
14587
14588#[repr(transparent)]
14589pub struct WireOptionalDirectoryRouterRouteResponse {
14590 raw: ::fidl_next::RawWireUnion,
14591 _phantom: ::core::marker::PhantomData<()>,
14592}
14593
14594unsafe impl ::fidl_next::Wire for WireOptionalDirectoryRouterRouteResponse {
14595 type Decoded<'de> = WireOptionalDirectoryRouterRouteResponse;
14596
14597 #[inline]
14598 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14599 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14600 ::fidl_next::RawWireUnion::zero_padding(raw);
14601 }
14602}
14603
14604impl WireOptionalDirectoryRouterRouteResponse {
14605 pub fn is_some(&self) -> bool {
14606 self.raw.is_some()
14607 }
14608
14609 pub fn is_none(&self) -> bool {
14610 self.raw.is_none()
14611 }
14612
14613 pub fn as_ref(&self) -> ::core::option::Option<&WireDirectoryRouterRouteResponse> {
14614 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14615 }
14616
14617 pub fn into_option(self) -> ::core::option::Option<WireDirectoryRouterRouteResponse> {
14618 if self.is_some() {
14619 Some(WireDirectoryRouterRouteResponse {
14620 raw: self.raw,
14621 _phantom: ::core::marker::PhantomData,
14622 })
14623 } else {
14624 None
14625 }
14626 }
14627}
14628
14629unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirectoryRouterRouteResponse
14630where
14631 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14632 ___D: ::fidl_next::fuchsia::HandleDecoder,
14633{
14634 fn decode(
14635 mut slot: ::fidl_next::Slot<'_, Self>,
14636 decoder: &mut ___D,
14637 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14638 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14639 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14640 1 => ::fidl_next::RawWireUnion::decode_as_static::<
14641 ___D,
14642 ::fidl_next::ClientEnd<
14643 ::fidl_next_fuchsia_io::Directory,
14644 ::fidl_next::fuchsia::WireChannel,
14645 >,
14646 >(raw, decoder)?,
14647
14648 2 => {
14649 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
14650 }
14651
14652 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14653 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14654 }
14655
14656 Ok(())
14657 }
14658}
14659
14660impl ::core::fmt::Debug for WireOptionalDirectoryRouterRouteResponse {
14661 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14662 self.as_ref().fmt(f)
14663 }
14664}
14665
14666#[derive(PartialEq, Debug)]
14668pub struct DirectoryRouter;
14669
14670impl ::fidl_next::Discoverable for DirectoryRouter {
14671 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
14672}
14673
14674pub mod directory_router {
14675 pub mod prelude {
14676 pub use crate::{
14677 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
14678 directory_router,
14679 };
14680
14681 pub use crate::DirectoryRouterRouteResponse;
14682
14683 pub use crate::RouteRequest;
14684
14685 pub use crate::RouterError;
14686 }
14687
14688 pub struct Route;
14689
14690 impl ::fidl_next::Method for Route {
14691 const ORDINAL: u64 = 7510716014181158689;
14692
14693 type Protocol = crate::DirectoryRouter;
14694
14695 type Request = crate::WireRouteRequest<'static>;
14696
14697 type Response = ::fidl_next::WireFlexibleResult<
14698 'static,
14699 crate::WireDirectoryRouterRouteResponse,
14700 crate::WireRouterError,
14701 >;
14702 }
14703
14704 mod ___detail {
14705
14706 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirectoryRouter
14707 where
14708 ___T: ::fidl_next::Transport,
14709 {
14710 type Client = DirectoryRouterClient<___T>;
14711 type Server = DirectoryRouterServer<___T>;
14712 }
14713
14714 #[repr(transparent)]
14716 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
14717 #[allow(dead_code)]
14718 client: ::fidl_next::protocol::Client<___T>,
14719 }
14720
14721 impl<___T> DirectoryRouterClient<___T>
14722 where
14723 ___T: ::fidl_next::Transport,
14724 {
14725 pub fn route_with<___R>(
14726 &self,
14727 request: ___R,
14728 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
14729 where
14730 ___R: ::fidl_next::Encode<
14731 <___T as ::fidl_next::Transport>::SendBuffer,
14732 Encoded = crate::WireRouteRequest<'static>,
14733 >,
14734 {
14735 ::fidl_next::TwoWayFuture::from_untyped(
14736 self.client.send_two_way(7510716014181158689, request),
14737 )
14738 }
14739 }
14740
14741 #[repr(transparent)]
14743 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
14744 server: ::fidl_next::protocol::Server<___T>,
14745 }
14746
14747 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
14748 }
14749}
14750
14751pub trait DirectoryRouterClientHandler<
14755 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14756 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14757>
14758{
14759 fn on_unknown_interaction(
14760 &mut self,
14761 ordinal: u64,
14762 ) -> impl ::core::future::Future<
14763 Output = ::core::result::Result<
14764 (),
14765 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14766 >,
14767 > + ::core::marker::Send {
14768 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14769 }
14770}
14771
14772impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
14773where
14774 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
14775 ___T: ::fidl_next::Transport,
14776 <directory_router::Route as ::fidl_next::Method>::Response:
14777 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14778{
14779 async fn on_event(
14780 handler: &mut ___H,
14781 ordinal: u64,
14782 buffer: ___T::RecvBuffer,
14783 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14784 match ordinal {
14785 ordinal => handler.on_unknown_interaction(ordinal).await,
14786 }
14787 }
14788}
14789
14790pub trait DirectoryRouterServerHandler<
14794 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14795 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14796>
14797{
14798 fn route(
14799 &mut self,
14800
14801 request: ::fidl_next::Request<directory_router::Route, ___T>,
14802
14803 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
14804 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14805
14806 fn on_unknown_interaction(
14807 &mut self,
14808 ordinal: u64,
14809 ) -> impl ::core::future::Future<
14810 Output = ::core::result::Result<
14811 (),
14812 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14813 >,
14814 > + ::core::marker::Send {
14815 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14816 }
14817}
14818
14819impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
14820where
14821 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
14822 ___T: ::fidl_next::Transport,
14823 <directory_router::Route as ::fidl_next::Method>::Request:
14824 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14825{
14826 async fn on_one_way(
14827 handler: &mut ___H,
14828 ordinal: u64,
14829 buffer: ___T::RecvBuffer,
14830 ) -> ::core::result::Result<
14831 (),
14832 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14833 > {
14834 match ordinal {
14835 ordinal => handler.on_unknown_interaction(ordinal).await,
14836 }
14837 }
14838
14839 async fn on_two_way(
14840 handler: &mut ___H,
14841 ordinal: u64,
14842 buffer: ___T::RecvBuffer,
14843 responder: ::fidl_next::protocol::Responder<___T>,
14844 ) -> ::core::result::Result<
14845 (),
14846 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14847 > {
14848 match ordinal {
14849 7510716014181158689 => {
14850 let responder = ::fidl_next::Responder::from_untyped(responder);
14851
14852 match ::fidl_next::DecoderExt::decode(buffer) {
14853 Ok(decoded) => {
14854 handler.route(decoded, responder).await;
14855 Ok(())
14856 }
14857 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14858 ordinal: 7510716014181158689,
14859 error,
14860 }),
14861 }
14862 }
14863
14864 ordinal => handler.on_unknown_interaction(ordinal).await,
14865 }
14866 }
14867}
14868
14869#[doc = " Contains a protocol open request.\n"]
14870#[derive(PartialEq, Debug)]
14871#[repr(C)]
14872pub struct ProtocolPayload {
14873 pub channel: ::fidl_next::fuchsia::zx::Channel,
14874}
14875
14876impl ::fidl_next::Encodable for ProtocolPayload {
14877 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireProtocolPayload> = unsafe {
14878 ::fidl_next::CopyOptimization::enable_if(
14879 true
14880 && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encodable>::COPY_OPTIMIZATION
14881 .is_enabled(),
14882 )
14883 };
14884
14885 type Encoded = WireProtocolPayload;
14886}
14887
14888unsafe impl<___E> ::fidl_next::Encode<___E> for ProtocolPayload
14889where
14890 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14891 ___E: ::fidl_next::fuchsia::HandleEncoder,
14892{
14893 #[inline]
14894 fn encode(
14895 self,
14896 encoder_: &mut ___E,
14897 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14898 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14899 ::fidl_next::munge! {
14900 let Self::Encoded {
14901 channel,
14902
14903 } = out_;
14904 }
14905
14906 ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
14907
14908 Ok(())
14909 }
14910}
14911
14912impl ::fidl_next::EncodableOption for ProtocolPayload {
14913 type EncodedOption = ::fidl_next::WireBox<'static, WireProtocolPayload>;
14914}
14915
14916unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ProtocolPayload
14917where
14918 ___E: ::fidl_next::Encoder + ?Sized,
14919 ProtocolPayload: ::fidl_next::Encode<___E>,
14920{
14921 #[inline]
14922 fn encode_option(
14923 this: ::core::option::Option<Self>,
14924 encoder: &mut ___E,
14925 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
14926 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14927 if let Some(inner) = this {
14928 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
14929 ::fidl_next::WireBox::encode_present(out);
14930 } else {
14931 ::fidl_next::WireBox::encode_absent(out);
14932 }
14933
14934 Ok(())
14935 }
14936}
14937
14938impl ::fidl_next::FromWire<WireProtocolPayload> for ProtocolPayload {
14939 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireProtocolPayload, Self> = unsafe {
14940 ::fidl_next::CopyOptimization::enable_if(
14941 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
14942 ::fidl_next::fuchsia::WireChannel,
14943 >>::COPY_OPTIMIZATION
14944 .is_enabled(),
14945 )
14946 };
14947
14948 #[inline]
14949 fn from_wire(wire: WireProtocolPayload) -> Self {
14950 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
14951 }
14952}
14953
14954impl ::fidl_next::IntoNatural for WireProtocolPayload {
14955 type Natural = ProtocolPayload;
14956}
14957
14958#[derive(Debug)]
14960#[repr(C)]
14961pub struct WireProtocolPayload {
14962 pub channel: ::fidl_next::fuchsia::WireChannel,
14963}
14964static_assertions::const_assert_eq!(std::mem::size_of::<WireProtocolPayload>(), 4);
14965static_assertions::const_assert_eq!(std::mem::align_of::<WireProtocolPayload>(), 4);
14966
14967static_assertions::const_assert_eq!(std::mem::offset_of!(WireProtocolPayload, channel), 0);
14968
14969unsafe impl ::fidl_next::Wire for WireProtocolPayload {
14970 type Decoded<'de> = WireProtocolPayload;
14971
14972 #[inline]
14973 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14974 ::fidl_next::munge! {
14975 let Self {
14976
14977 channel,
14978
14979 } = &mut *out_;
14980 }
14981
14982 ::fidl_next::Wire::zero_padding(channel);
14983 }
14984}
14985
14986unsafe impl<___D> ::fidl_next::Decode<___D> for WireProtocolPayload
14987where
14988 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14989 ___D: ::fidl_next::fuchsia::HandleDecoder,
14990{
14991 fn decode(
14992 slot_: ::fidl_next::Slot<'_, Self>,
14993 decoder_: &mut ___D,
14994 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14995 ::fidl_next::munge! {
14996 let Self {
14997
14998 mut channel,
14999
15000 } = slot_;
15001 }
15002
15003 ::fidl_next::Decode::decode(channel.as_mut(), decoder_)?;
15004
15005 Ok(())
15006 }
15007}
15008
15009#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
15011#[derive(PartialEq, Debug)]
15012pub struct Receiver;
15013
15014impl ::fidl_next::Discoverable for Receiver {
15015 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
15016}
15017
15018pub mod receiver {
15019 pub mod prelude {
15020 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
15021
15022 pub use crate::ProtocolPayload;
15023 }
15024
15025 pub struct Receive;
15026
15027 impl ::fidl_next::Method for Receive {
15028 const ORDINAL: u64 = 340832707723008660;
15029
15030 type Protocol = crate::Receiver;
15031
15032 type Request = crate::WireProtocolPayload;
15033
15034 type Response = ::fidl_next::Never;
15035 }
15036
15037 mod ___detail {
15038
15039 pub struct Receive<T0> {
15040 channel: T0,
15041 }
15042
15043 impl<T0> ::fidl_next::Encodable for Receive<T0>
15044 where
15045 T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
15046 {
15047 type Encoded = crate::WireProtocolPayload;
15048 }
15049
15050 unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Receive<T0>
15051 where
15052 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15053 ___E: ::fidl_next::fuchsia::HandleEncoder,
15054 T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
15055 {
15056 #[inline]
15057 fn encode(
15058 self,
15059 encoder_: &mut ___E,
15060 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15061 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15062 ::fidl_next::munge! {
15063 let Self::Encoded {
15064 channel,
15065
15066 } = out_;
15067 }
15068
15069 ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
15070
15071 Ok(())
15072 }
15073 }
15074
15075 unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Receiver
15076 where
15077 ___T: ::fidl_next::Transport,
15078 {
15079 type Client = ReceiverClient<___T>;
15080 type Server = ReceiverServer<___T>;
15081 }
15082
15083 #[repr(transparent)]
15085 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
15086 #[allow(dead_code)]
15087 client: ::fidl_next::protocol::Client<___T>,
15088 }
15089
15090 impl<___T> ReceiverClient<___T>
15091 where
15092 ___T: ::fidl_next::Transport,
15093 {
15094 #[doc = " Sends a channel to this receiver.\n"]
15095 pub fn receive(
15096 &self,
15097
15098 channel: impl ::fidl_next::Encode<
15099 <___T as ::fidl_next::Transport>::SendBuffer,
15100 Encoded = ::fidl_next::fuchsia::WireChannel,
15101 >,
15102 ) -> ::fidl_next::SendFuture<'_, ___T>
15103 where
15104 <___T as ::fidl_next::Transport>::SendBuffer:
15105 ::fidl_next::encoder::InternalHandleEncoder,
15106 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15107 {
15108 self.receive_with(Receive { channel })
15109 }
15110
15111 #[doc = " Sends a channel to this receiver.\n"]
15112 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
15113 where
15114 ___R: ::fidl_next::Encode<
15115 <___T as ::fidl_next::Transport>::SendBuffer,
15116 Encoded = crate::WireProtocolPayload,
15117 >,
15118 {
15119 ::fidl_next::SendFuture::from_untyped(
15120 self.client.send_one_way(340832707723008660, request),
15121 )
15122 }
15123 }
15124
15125 #[repr(transparent)]
15127 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
15128 server: ::fidl_next::protocol::Server<___T>,
15129 }
15130
15131 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
15132 }
15133}
15134
15135pub trait ReceiverClientHandler<
15139 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
15140 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15141>
15142{
15143 fn on_unknown_interaction(
15144 &mut self,
15145 ordinal: u64,
15146 ) -> impl ::core::future::Future<
15147 Output = ::core::result::Result<
15148 (),
15149 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15150 >,
15151 > + ::core::marker::Send {
15152 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
15153 }
15154}
15155
15156impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
15157where
15158 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
15159 ___T: ::fidl_next::Transport,
15160{
15161 async fn on_event(
15162 handler: &mut ___H,
15163 ordinal: u64,
15164 buffer: ___T::RecvBuffer,
15165 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15166 match ordinal {
15167 ordinal => handler.on_unknown_interaction(ordinal).await,
15168 }
15169 }
15170}
15171
15172pub trait ReceiverServerHandler<
15176 #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
15177 #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15178>
15179{
15180 #[doc = " Sends a channel to this receiver.\n"]
15181 fn receive(
15182 &mut self,
15183
15184 request: ::fidl_next::Request<receiver::Receive, ___T>,
15185 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15186
15187 fn on_unknown_interaction(
15188 &mut self,
15189 ordinal: u64,
15190 ) -> impl ::core::future::Future<
15191 Output = ::core::result::Result<
15192 (),
15193 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15194 >,
15195 > + ::core::marker::Send {
15196 ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
15197 }
15198}
15199
15200impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
15201where
15202 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
15203 ___T: ::fidl_next::Transport,
15204 <receiver::Receive as ::fidl_next::Method>::Request:
15205 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
15206{
15207 async fn on_one_way(
15208 handler: &mut ___H,
15209 ordinal: u64,
15210 buffer: ___T::RecvBuffer,
15211 ) -> ::core::result::Result<
15212 (),
15213 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15214 > {
15215 match ordinal {
15216 340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
15217 Ok(decoded) => {
15218 handler.receive(decoded).await;
15219 Ok(())
15220 }
15221 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15222 ordinal: 340832707723008660,
15223 error,
15224 }),
15225 },
15226
15227 ordinal => handler.on_unknown_interaction(ordinal).await,
15228 }
15229 }
15230
15231 async fn on_two_way(
15232 handler: &mut ___H,
15233 ordinal: u64,
15234 buffer: ___T::RecvBuffer,
15235 responder: ::fidl_next::protocol::Responder<___T>,
15236 ) -> ::core::result::Result<
15237 (),
15238 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15239 > {
15240 match ordinal {
15241 ordinal => handler.on_unknown_interaction(ordinal).await,
15242 }
15243 }
15244}
15245
15246#[derive(PartialEq, Clone, Debug)]
15247#[repr(C)]
15248pub struct Unavailable {}
15249
15250impl ::fidl_next::Encodable for Unavailable {
15251 type Encoded = WireUnavailable;
15252}
15253
15254unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
15255where
15256 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15257{
15258 #[inline]
15259 fn encode(
15260 self,
15261 encoder_: &mut ___E,
15262 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15263 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15264 *out_ = ::core::mem::MaybeUninit::zeroed();
15265
15266 Ok(())
15267 }
15268}
15269
15270unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unavailable
15271where
15272 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15273{
15274 #[inline]
15275 fn encode_ref(
15276 &self,
15277 encoder_: &mut ___E,
15278 out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15279 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15280 ::fidl_next::munge! {
15281 let Self::Encoded {
15282
15283 _empty,
15284
15285
15286 } = out_;
15287 }
15288
15289 Ok(())
15290 }
15291}
15292
15293impl ::fidl_next::EncodableOption for Unavailable {
15294 type EncodedOption = ::fidl_next::WireBox<'static, WireUnavailable>;
15295}
15296
15297unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unavailable
15298where
15299 ___E: ::fidl_next::Encoder + ?Sized,
15300 Unavailable: ::fidl_next::Encode<___E>,
15301{
15302 #[inline]
15303 fn encode_option(
15304 this: ::core::option::Option<Self>,
15305 encoder: &mut ___E,
15306 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
15307 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15308 if let Some(inner) = this {
15309 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
15310 ::fidl_next::WireBox::encode_present(out);
15311 } else {
15312 ::fidl_next::WireBox::encode_absent(out);
15313 }
15314
15315 Ok(())
15316 }
15317}
15318
15319unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unavailable
15320where
15321 ___E: ::fidl_next::Encoder + ?Sized,
15322 Unavailable: ::fidl_next::EncodeRef<___E>,
15323{
15324 #[inline]
15325 fn encode_option_ref(
15326 this: ::core::option::Option<&Self>,
15327 encoder: &mut ___E,
15328 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
15329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15330 if let Some(inner) = this {
15331 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
15332 ::fidl_next::WireBox::encode_present(out);
15333 } else {
15334 ::fidl_next::WireBox::encode_absent(out);
15335 }
15336
15337 Ok(())
15338 }
15339}
15340
15341impl ::fidl_next::FromWire<WireUnavailable> for Unavailable {
15342 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireUnavailable, Self> =
15343 unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
15344
15345 #[inline]
15346 fn from_wire(wire: WireUnavailable) -> Self {
15347 Self {}
15348 }
15349}
15350
15351impl ::fidl_next::IntoNatural for WireUnavailable {
15352 type Natural = Unavailable;
15353}
15354
15355impl ::fidl_next::FromWireRef<WireUnavailable> for Unavailable {
15356 #[inline]
15357 fn from_wire_ref(wire: &WireUnavailable) -> Self {
15358 Self {}
15359 }
15360}
15361
15362#[derive(Clone, Debug)]
15364#[repr(C)]
15365pub struct WireUnavailable {
15366 _empty: fidl_next::WireEmptyStructPlaceholder,
15367}
15368static_assertions::const_assert_eq!(std::mem::size_of::<WireUnavailable>(), 1);
15369static_assertions::const_assert_eq!(std::mem::align_of::<WireUnavailable>(), 1);
15370
15371unsafe impl ::fidl_next::Wire for WireUnavailable {
15372 type Decoded<'de> = WireUnavailable;
15373
15374 #[inline]
15375 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15376 ::fidl_next::munge! {
15377 let Self {
15378
15379 _empty,
15380
15381
15382 } = &mut *out_;
15383 }
15384 }
15385}
15386
15387unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnavailable
15388where
15389 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15390{
15391 fn decode(
15392 slot_: ::fidl_next::Slot<'_, Self>,
15393 decoder_: &mut ___D,
15394 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15395 ::fidl_next::munge! {
15396 let Self {
15397
15398 mut _empty,
15399
15400
15401 } = slot_;
15402 }
15403
15404 if _empty.as_bytes() != &[0u8] {
15405 return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
15406 }
15407
15408 Ok(())
15409 }
15410}
15411
15412pub mod compat {
15414
15415 impl ::fidl_next::CompatFrom<crate::Availability>
15416 for ::fidl_fuchsia_component_sandbox::Availability
15417 {
15418 fn compat_from(value: crate::Availability) -> Self {
15419 match value {
15420 crate::Availability::Required => Self::Required,
15421
15422 crate::Availability::Optional => Self::Optional,
15423
15424 crate::Availability::SameAsTarget => Self::SameAsTarget,
15425
15426 crate::Availability::Transitional => Self::Transitional,
15427 }
15428 }
15429 }
15430
15431 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Availability>
15432 for crate::Availability
15433 {
15434 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Availability) -> Self {
15435 match value {
15436 ::fidl_fuchsia_component_sandbox::Availability::Required => Self::Required,
15437
15438 ::fidl_fuchsia_component_sandbox::Availability::Optional => Self::Optional,
15439
15440 ::fidl_fuchsia_component_sandbox::Availability::SameAsTarget => Self::SameAsTarget,
15441
15442 ::fidl_fuchsia_component_sandbox::Availability::Transitional => Self::Transitional,
15443 }
15444 }
15445 }
15446
15447 impl ::fidl_next::CompatFrom<crate::Unit> for ::fidl_fuchsia_component_sandbox::Unit {
15448 #[inline]
15449 fn compat_from(value: crate::Unit) -> Self {
15450 Self {}
15451 }
15452 }
15453
15454 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unit> for crate::Unit {
15455 #[inline]
15456 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unit) -> Self {
15457 Self {}
15458 }
15459 }
15460
15461 impl ::fidl_next::CompatFrom<crate::Data> for ::fidl_fuchsia_component_sandbox::Data {
15462 fn compat_from(value: crate::Data) -> Self {
15463 match value {
15464 crate::Data::Bytes(value) => {
15465 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15466 }
15467
15468 crate::Data::String(value) => {
15469 Self::String(::fidl_next::CompatFrom::compat_from(value))
15470 }
15471
15472 crate::Data::Int64(value) => {
15473 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
15474 }
15475
15476 crate::Data::Uint64(value) => {
15477 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
15478 }
15479
15480 crate::Data::UnknownOrdinal_(unknown_ordinal) => {
15481 Self::__SourceBreaking { unknown_ordinal }
15482 }
15483 }
15484 }
15485 }
15486
15487 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Data> for crate::Data {
15488 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Data) -> Self {
15489 match value {
15490 ::fidl_fuchsia_component_sandbox::Data::Bytes(value) => {
15491 Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15492 }
15493
15494 ::fidl_fuchsia_component_sandbox::Data::String(value) => {
15495 Self::String(::fidl_next::CompatFrom::compat_from(value))
15496 }
15497
15498 ::fidl_fuchsia_component_sandbox::Data::Int64(value) => {
15499 Self::Int64(::fidl_next::CompatFrom::compat_from(value))
15500 }
15501
15502 ::fidl_fuchsia_component_sandbox::Data::Uint64(value) => {
15503 Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
15504 }
15505
15506 ::fidl_fuchsia_component_sandbox::Data::__SourceBreaking { unknown_ordinal } => {
15507 Self::UnknownOrdinal_(unknown_ordinal)
15508 }
15509 }
15510 }
15511 }
15512
15513 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
15514 for ::fidl_fuchsia_component_sandbox::DictionaryRef
15515 {
15516 #[inline]
15517 fn compat_from(value: crate::DictionaryRef) -> Self {
15518 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15519 }
15520 }
15521
15522 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
15523 for crate::DictionaryRef
15524 {
15525 #[inline]
15526 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
15527 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15528 }
15529 }
15530
15531 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
15532 #[inline]
15533 fn compat_from(value: crate::Connector) -> Self {
15534 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15535 }
15536 }
15537
15538 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
15539 #[inline]
15540 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
15541 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15542 }
15543 }
15544
15545 impl ::fidl_next::CompatFrom<crate::DirConnector>
15546 for ::fidl_fuchsia_component_sandbox::DirConnector
15547 {
15548 #[inline]
15549 fn compat_from(value: crate::DirConnector) -> Self {
15550 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15551 }
15552 }
15553
15554 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
15555 for crate::DirConnector
15556 {
15557 #[inline]
15558 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
15559 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15560 }
15561 }
15562
15563 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
15564 #[inline]
15565 fn compat_from(value: crate::DirEntry) -> Self {
15566 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15567 }
15568 }
15569
15570 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
15571 #[inline]
15572 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
15573 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15574 }
15575 }
15576
15577 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
15578 fn compat_from(value: crate::Capability) -> Self {
15579 match value {
15580 crate::Capability::Unit(value) => {
15581 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
15582 }
15583
15584 crate::Capability::Handle(value) => {
15585 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
15586 }
15587
15588 crate::Capability::Data(value) => {
15589 Self::Data(::fidl_next::CompatFrom::compat_from(value))
15590 }
15591
15592 crate::Capability::Dictionary(value) => {
15593 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
15594 }
15595
15596 crate::Capability::Connector(value) => {
15597 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
15598 }
15599
15600 crate::Capability::DirConnector(value) => {
15601 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
15602 }
15603
15604 crate::Capability::Directory(value) => {
15605 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15606 }
15607
15608 crate::Capability::DirEntry(value) => {
15609 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15610 }
15611
15612 crate::Capability::ConnectorRouter(value) => {
15613 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15614 }
15615
15616 crate::Capability::DictionaryRouter(value) => {
15617 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
15618 }
15619
15620 crate::Capability::DirEntryRouter(value) => {
15621 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
15622 }
15623
15624 crate::Capability::DataRouter(value) => {
15625 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
15626 }
15627
15628 crate::Capability::DirConnectorRouter(value) => {
15629 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15630 }
15631
15632 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
15633 Self::__SourceBreaking { unknown_ordinal }
15634 }
15635 }
15636 }
15637 }
15638
15639 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
15640 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
15641 match value {
15642 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
15643 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
15644 }
15645
15646 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
15647 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
15648 }
15649
15650 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
15651 Self::Data(::fidl_next::CompatFrom::compat_from(value))
15652 }
15653
15654 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
15655 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
15656 }
15657
15658 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
15659 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
15660 }
15661
15662 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
15663 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
15664 }
15665
15666 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
15667 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15668 }
15669
15670 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
15671 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15672 }
15673
15674 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
15675 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15676 }
15677
15678 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
15679 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
15680 }
15681
15682 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
15683 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
15684 }
15685
15686 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
15687 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
15688 }
15689
15690 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
15691 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15692 }
15693
15694 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
15695 unknown_ordinal,
15696 } => Self::UnknownOrdinal_(unknown_ordinal),
15697 }
15698 }
15699 }
15700
15701 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDuplicateRequest>
15702 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
15703 {
15704 #[inline]
15705 fn compat_from(value: crate::CapabilityStoreDuplicateRequest) -> Self {
15706 Self {
15707 id: ::fidl_next::CompatFrom::compat_from(value.id),
15708
15709 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
15710 }
15711 }
15712 }
15713
15714 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest>
15715 for crate::CapabilityStoreDuplicateRequest
15716 {
15717 #[inline]
15718 fn compat_from(
15719 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest,
15720 ) -> Self {
15721 Self {
15722 id: ::fidl_next::CompatFrom::compat_from(value.id),
15723
15724 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
15725 }
15726 }
15727 }
15728
15729 impl ::fidl_next::CompatFrom<crate::CapabilityStoreError>
15730 for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
15731 {
15732 fn compat_from(value: crate::CapabilityStoreError) -> Self {
15733 match value {
15734 crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,
15735
15736 crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,
15737
15738 crate::CapabilityStoreError::BadCapability => Self::BadCapability,
15739
15740 crate::CapabilityStoreError::WrongType => Self::WrongType,
15741
15742 crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,
15743
15744 crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,
15745
15746 crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,
15747
15748 crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,
15749
15750 crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,
15751
15752 crate::CapabilityStoreError::UnknownOrdinal_(unknown_ordinal) => {
15753 Self::__SourceBreaking { unknown_ordinal }
15754 }
15755 }
15756 }
15757 }
15758
15759 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreError>
15760 for crate::CapabilityStoreError
15761 {
15762 fn compat_from(value: ::fidl_fuchsia_component_sandbox::CapabilityStoreError) -> Self {
15763 match value {
15764 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdNotFound => {
15765 Self::IdNotFound
15766 }
15767
15768 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdAlreadyExists => {
15769 Self::IdAlreadyExists
15770 }
15771
15772 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::BadCapability => {
15773 Self::BadCapability
15774 }
15775
15776 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::WrongType => {
15777 Self::WrongType
15778 }
15779
15780 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::NotDuplicatable => {
15781 Self::NotDuplicatable
15782 }
15783
15784 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemNotFound => {
15785 Self::ItemNotFound
15786 }
15787
15788 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemAlreadyExists => {
15789 Self::ItemAlreadyExists
15790 }
15791
15792 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidKey => {
15793 Self::InvalidKey
15794 }
15795
15796 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidArgs => {
15797 Self::InvalidArgs
15798 }
15799
15800 ::fidl_fuchsia_component_sandbox::CapabilityStoreError::__SourceBreaking {
15801 unknown_ordinal: value,
15802 } => Self::UnknownOrdinal_(value),
15803 }
15804 }
15805 }
15806
15807 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDropRequest>
15808 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
15809 {
15810 #[inline]
15811 fn compat_from(value: crate::CapabilityStoreDropRequest) -> Self {
15812 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15813 }
15814 }
15815
15816 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest>
15817 for crate::CapabilityStoreDropRequest
15818 {
15819 #[inline]
15820 fn compat_from(
15821 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest,
15822 ) -> Self {
15823 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15824 }
15825 }
15826
15827 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportRequest>
15828 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
15829 {
15830 #[inline]
15831 fn compat_from(value: crate::CapabilityStoreExportRequest) -> Self {
15832 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15833 }
15834 }
15835
15836 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest>
15837 for crate::CapabilityStoreExportRequest
15838 {
15839 #[inline]
15840 fn compat_from(
15841 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest,
15842 ) -> Self {
15843 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15844 }
15845 }
15846
15847 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
15848 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
15849 {
15850 #[inline]
15851 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
15852 Self {
15853 id: ::fidl_next::CompatFrom::compat_from(value.id),
15854
15855 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
15856 }
15857 }
15858 }
15859
15860 impl
15861 ::fidl_next::CompatFrom<
15862 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
15863 > for crate::CapabilityStoreConnectorCreateRequest
15864 {
15865 #[inline]
15866 fn compat_from(
15867 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
15868 ) -> Self {
15869 Self {
15870 id: ::fidl_next::CompatFrom::compat_from(value.id),
15871
15872 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
15873 }
15874 }
15875 }
15876
15877 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
15878 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
15879 {
15880 #[inline]
15881 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
15882 Self {
15883 id: ::fidl_next::CompatFrom::compat_from(value.id),
15884
15885 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15886 }
15887 }
15888 }
15889
15890 impl
15891 ::fidl_next::CompatFrom<
15892 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
15893 > for crate::CapabilityStoreConnectorOpenRequest
15894 {
15895 #[inline]
15896 fn compat_from(
15897 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
15898 ) -> Self {
15899 Self {
15900 id: ::fidl_next::CompatFrom::compat_from(value.id),
15901
15902 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15903 }
15904 }
15905 }
15906
15907 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCreateRequest>
15908 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
15909 {
15910 #[inline]
15911 fn compat_from(value: crate::CapabilityStoreDictionaryCreateRequest) -> Self {
15912 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15913 }
15914 }
15915
15916 impl
15917 ::fidl_next::CompatFrom<
15918 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
15919 > for crate::CapabilityStoreDictionaryCreateRequest
15920 {
15921 #[inline]
15922 fn compat_from(
15923 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
15924 ) -> Self {
15925 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15926 }
15927 }
15928
15929 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
15930 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
15931 {
15932 #[inline]
15933 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
15934 Self {
15935 id: ::fidl_next::CompatFrom::compat_from(value.id),
15936
15937 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
15938 }
15939 }
15940 }
15941
15942 impl
15943 ::fidl_next::CompatFrom<
15944 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
15945 > for crate::CapabilityStoreDictionaryLegacyImportRequest
15946 {
15947 #[inline]
15948 fn compat_from(
15949 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
15950 ) -> Self {
15951 Self {
15952 id: ::fidl_next::CompatFrom::compat_from(value.id),
15953
15954 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
15955 }
15956 }
15957 }
15958
15959 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
15960 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
15961 {
15962 #[inline]
15963 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
15964 Self {
15965 id: ::fidl_next::CompatFrom::compat_from(value.id),
15966
15967 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15968 }
15969 }
15970 }
15971
15972 impl
15973 ::fidl_next::CompatFrom<
15974 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
15975 > for crate::CapabilityStoreDictionaryLegacyExportRequest
15976 {
15977 #[inline]
15978 fn compat_from(
15979 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
15980 ) -> Self {
15981 Self {
15982 id: ::fidl_next::CompatFrom::compat_from(value.id),
15983
15984 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15985 }
15986 }
15987 }
15988
15989 impl ::fidl_next::CompatFrom<crate::DictionaryItem>
15990 for ::fidl_fuchsia_component_sandbox::DictionaryItem
15991 {
15992 #[inline]
15993 fn compat_from(value: crate::DictionaryItem) -> Self {
15994 Self {
15995 key: ::fidl_next::CompatFrom::compat_from(value.key),
15996
15997 value: ::fidl_next::CompatFrom::compat_from(value.value),
15998 }
15999 }
16000 }
16001
16002 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryItem>
16003 for crate::DictionaryItem
16004 {
16005 #[inline]
16006 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryItem) -> Self {
16007 Self {
16008 key: ::fidl_next::CompatFrom::compat_from(value.key),
16009
16010 value: ::fidl_next::CompatFrom::compat_from(value.value),
16011 }
16012 }
16013 }
16014
16015 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryInsertRequest>
16016 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
16017 {
16018 #[inline]
16019 fn compat_from(value: crate::CapabilityStoreDictionaryInsertRequest) -> Self {
16020 Self {
16021 id: ::fidl_next::CompatFrom::compat_from(value.id),
16022
16023 item: ::fidl_next::CompatFrom::compat_from(value.item),
16024 }
16025 }
16026 }
16027
16028 impl
16029 ::fidl_next::CompatFrom<
16030 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
16031 > for crate::CapabilityStoreDictionaryInsertRequest
16032 {
16033 #[inline]
16034 fn compat_from(
16035 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
16036 ) -> Self {
16037 Self {
16038 id: ::fidl_next::CompatFrom::compat_from(value.id),
16039
16040 item: ::fidl_next::CompatFrom::compat_from(value.item),
16041 }
16042 }
16043 }
16044
16045 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryGetRequest>
16046 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
16047 {
16048 #[inline]
16049 fn compat_from(value: crate::CapabilityStoreDictionaryGetRequest) -> Self {
16050 Self {
16051 id: ::fidl_next::CompatFrom::compat_from(value.id),
16052
16053 key: ::fidl_next::CompatFrom::compat_from(value.key),
16054
16055 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16056 }
16057 }
16058 }
16059
16060 impl
16061 ::fidl_next::CompatFrom<
16062 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
16063 > for crate::CapabilityStoreDictionaryGetRequest
16064 {
16065 #[inline]
16066 fn compat_from(
16067 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
16068 ) -> Self {
16069 Self {
16070 id: ::fidl_next::CompatFrom::compat_from(value.id),
16071
16072 key: ::fidl_next::CompatFrom::compat_from(value.key),
16073
16074 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16075 }
16076 }
16077 }
16078
16079 impl ::fidl_next::CompatFrom<crate::WrappedCapabilityId>
16080 for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
16081 {
16082 #[inline]
16083 fn compat_from(value: crate::WrappedCapabilityId) -> Self {
16084 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
16085 }
16086 }
16087
16088 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::WrappedCapabilityId>
16089 for crate::WrappedCapabilityId
16090 {
16091 #[inline]
16092 fn compat_from(value: ::fidl_fuchsia_component_sandbox::WrappedCapabilityId) -> Self {
16093 Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
16094 }
16095 }
16096
16097 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryRemoveRequest>
16098 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
16099 {
16100 #[inline]
16101 fn compat_from(value: crate::CapabilityStoreDictionaryRemoveRequest) -> Self {
16102 Self {
16103 id: ::fidl_next::CompatFrom::compat_from(value.id),
16104
16105 key: ::fidl_next::CompatFrom::compat_from(value.key),
16106
16107 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16108 }
16109 }
16110 }
16111
16112 impl
16113 ::fidl_next::CompatFrom<
16114 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
16115 > for crate::CapabilityStoreDictionaryRemoveRequest
16116 {
16117 #[inline]
16118 fn compat_from(
16119 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
16120 ) -> Self {
16121 Self {
16122 id: ::fidl_next::CompatFrom::compat_from(value.id),
16123
16124 key: ::fidl_next::CompatFrom::compat_from(value.key),
16125
16126 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16127 }
16128 }
16129 }
16130
16131 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCopyRequest>
16132 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
16133 {
16134 #[inline]
16135 fn compat_from(value: crate::CapabilityStoreDictionaryCopyRequest) -> Self {
16136 Self {
16137 id: ::fidl_next::CompatFrom::compat_from(value.id),
16138
16139 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16140 }
16141 }
16142 }
16143
16144 impl
16145 ::fidl_next::CompatFrom<
16146 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
16147 > for crate::CapabilityStoreDictionaryCopyRequest
16148 {
16149 #[inline]
16150 fn compat_from(
16151 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
16152 ) -> Self {
16153 Self {
16154 id: ::fidl_next::CompatFrom::compat_from(value.id),
16155
16156 dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16157 }
16158 }
16159 }
16160
16161 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
16162 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
16163 {
16164 #[inline]
16165 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
16166 Self {
16167 id: ::fidl_next::CompatFrom::compat_from(value.id),
16168
16169 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16170 }
16171 }
16172 }
16173
16174 impl
16175 ::fidl_next::CompatFrom<
16176 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
16177 > for crate::CapabilityStoreDictionaryKeysRequest
16178 {
16179 #[inline]
16180 fn compat_from(
16181 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
16182 ) -> Self {
16183 Self {
16184 id: ::fidl_next::CompatFrom::compat_from(value.id),
16185
16186 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16187 }
16188 }
16189 }
16190
16191 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
16192 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
16193 {
16194 #[inline]
16195 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
16196 Self {
16197 id: ::fidl_next::CompatFrom::compat_from(value.id),
16198
16199 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16200 }
16201 }
16202 }
16203
16204 impl
16205 ::fidl_next::CompatFrom<
16206 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
16207 > for crate::CapabilityStoreDictionaryEnumerateRequest
16208 {
16209 #[inline]
16210 fn compat_from(
16211 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
16212 ) -> Self {
16213 Self {
16214 id: ::fidl_next::CompatFrom::compat_from(value.id),
16215
16216 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16217 }
16218 }
16219 }
16220
16221 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
16222 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
16223 {
16224 #[inline]
16225 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
16226 Self {
16227 id: ::fidl_next::CompatFrom::compat_from(value.id),
16228
16229 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16230 }
16231 }
16232 }
16233
16234 impl
16235 ::fidl_next::CompatFrom<
16236 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
16237 > for crate::CapabilityStoreDictionaryDrainRequest
16238 {
16239 #[inline]
16240 fn compat_from(
16241 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
16242 ) -> Self {
16243 Self {
16244 id: ::fidl_next::CompatFrom::compat_from(value.id),
16245
16246 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16247 }
16248 }
16249 }
16250
16251 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
16252 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
16253 {
16254 #[inline]
16255 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
16256 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
16257 }
16258 }
16259
16260 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
16261 for crate::CapabilityStoreExportResponse
16262 {
16263 #[inline]
16264 fn compat_from(
16265 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
16266 ) -> Self {
16267 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
16268 }
16269 }
16270
16271 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
16272 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
16273 {
16274 #[inline]
16275 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
16276 Self {
16277 id: ::fidl_next::CompatFrom::compat_from(value.id),
16278
16279 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
16280 }
16281 }
16282 }
16283
16284 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
16285 for crate::CapabilityStoreImportRequest
16286 {
16287 #[inline]
16288 fn compat_from(
16289 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
16290 ) -> Self {
16291 Self {
16292 id: ::fidl_next::CompatFrom::compat_from(value.id),
16293
16294 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
16295 }
16296 }
16297 }
16298
16299 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
16300 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
16301 {
16302 #[inline]
16303 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
16304 Self {
16305 id: ::fidl_next::CompatFrom::compat_from(value.id),
16306
16307 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
16308 }
16309 }
16310 }
16311
16312 impl
16313 ::fidl_next::CompatFrom<
16314 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
16315 > for crate::CapabilityStoreDirConnectorCreateRequest
16316 {
16317 #[inline]
16318 fn compat_from(
16319 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
16320 ) -> Self {
16321 Self {
16322 id: ::fidl_next::CompatFrom::compat_from(value.id),
16323
16324 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
16325 }
16326 }
16327 }
16328
16329 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
16330 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
16331 {
16332 #[inline]
16333 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
16334 Self {
16335 id: ::fidl_next::CompatFrom::compat_from(value.id),
16336
16337 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
16338 }
16339 }
16340 }
16341
16342 impl
16343 ::fidl_next::CompatFrom<
16344 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
16345 > for crate::CapabilityStoreDirConnectorOpenRequest
16346 {
16347 #[inline]
16348 fn compat_from(
16349 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
16350 ) -> Self {
16351 Self {
16352 id: ::fidl_next::CompatFrom::compat_from(value.id),
16353
16354 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
16355 }
16356 }
16357 }
16358
16359 #[cfg(target_os = "fuchsia")]
16360 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
16363
16364 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
16365 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
16366 {
16367 fn compat_from(_: crate::CapabilityStore) -> Self {
16368 Self
16369 }
16370 }
16371
16372 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
16373 for crate::CapabilityStore
16374 {
16375 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
16376 Self
16377 }
16378 }
16379
16380 #[cfg(target_os = "fuchsia")]
16381
16382 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
16383 for crate::CapabilityStore
16384 {
16385 fn client_compat_from(
16386 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
16387 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16388 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16389 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16390 ::fidl_next::ClientDispatcher::new(client_end)
16391 }
16392 }
16393
16394 impl ::fidl_next::CompatFrom<crate::InstanceToken>
16395 for ::fidl_fuchsia_component_sandbox::InstanceToken
16396 {
16397 #[inline]
16398 fn compat_from(value: crate::InstanceToken) -> Self {
16399 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
16400 }
16401 }
16402
16403 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
16404 for crate::InstanceToken
16405 {
16406 #[inline]
16407 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
16408 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
16409 }
16410 }
16411
16412 impl ::fidl_next::CompatFrom<crate::RouteRequest>
16413 for ::fidl_fuchsia_component_sandbox::RouteRequest
16414 {
16415 fn compat_from(value: crate::RouteRequest) -> Self {
16416 Self {
16417 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
16418
16419 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
16420
16421 __source_breaking: ::fidl::marker::SourceBreaking,
16422 }
16423 }
16424 }
16425
16426 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
16427 for crate::RouteRequest
16428 {
16429 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
16430 Self {
16431 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
16432
16433 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
16434 }
16435 }
16436 }
16437
16438 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
16439 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
16440 {
16441 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
16442 match value {
16443 crate::ConnectorRouterRouteResponse::Connector(value) => {
16444 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
16445 }
16446
16447 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
16448 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16449 }
16450 }
16451 }
16452 }
16453
16454 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
16455 for crate::ConnectorRouterRouteResponse
16456 {
16457 fn compat_from(
16458 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
16459 ) -> Self {
16460 match value {
16461 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
16462 value,
16463 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
16464
16465 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
16466 value,
16467 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
16468 }
16469 }
16470 }
16471
16472 impl ::fidl_next::CompatFrom<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
16473 fn compat_from(value: crate::RouterError) -> Self {
16474 match value {
16475 crate::RouterError::NotFound => Self::NotFound,
16476
16477 crate::RouterError::InvalidArgs => Self::InvalidArgs,
16478
16479 crate::RouterError::NotSupported => Self::NotSupported,
16480
16481 crate::RouterError::Internal => Self::Internal,
16482
16483 crate::RouterError::UnknownOrdinal_(unknown_ordinal) => {
16484 Self::__SourceBreaking { unknown_ordinal }
16485 }
16486 }
16487 }
16488 }
16489
16490 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouterError> for crate::RouterError {
16491 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouterError) -> Self {
16492 match value {
16493 ::fidl_fuchsia_component_sandbox::RouterError::NotFound => Self::NotFound,
16494
16495 ::fidl_fuchsia_component_sandbox::RouterError::InvalidArgs => Self::InvalidArgs,
16496
16497 ::fidl_fuchsia_component_sandbox::RouterError::NotSupported => Self::NotSupported,
16498
16499 ::fidl_fuchsia_component_sandbox::RouterError::Internal => Self::Internal,
16500
16501 ::fidl_fuchsia_component_sandbox::RouterError::__SourceBreaking {
16502 unknown_ordinal: value,
16503 } => Self::UnknownOrdinal_(value),
16504 }
16505 }
16506 }
16507
16508 #[cfg(target_os = "fuchsia")]
16509 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
16512
16513 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
16514 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
16515 {
16516 fn compat_from(_: crate::ConnectorRouter) -> Self {
16517 Self
16518 }
16519 }
16520
16521 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
16522 for crate::ConnectorRouter
16523 {
16524 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
16525 Self
16526 }
16527 }
16528
16529 #[cfg(target_os = "fuchsia")]
16530
16531 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
16532 for crate::ConnectorRouter
16533 {
16534 fn client_compat_from(
16535 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
16536 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16537 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16538 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16539 ::fidl_next::ClientDispatcher::new(client_end)
16540 }
16541 }
16542
16543 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
16544 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
16545 {
16546 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
16547 match value {
16548 crate::DataRouterRouteResponse::Data(value) => {
16549 Self::Data(::fidl_next::CompatFrom::compat_from(value))
16550 }
16551
16552 crate::DataRouterRouteResponse::Unavailable(value) => {
16553 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16554 }
16555 }
16556 }
16557 }
16558
16559 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
16560 for crate::DataRouterRouteResponse
16561 {
16562 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
16563 match value {
16564 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
16565 Self::Data(::fidl_next::CompatFrom::compat_from(value))
16566 }
16567
16568 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
16569 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16570 }
16571 }
16572 }
16573 }
16574
16575 #[cfg(target_os = "fuchsia")]
16576 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
16579
16580 impl ::fidl_next::CompatFrom<crate::DataRouter>
16581 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
16582 {
16583 fn compat_from(_: crate::DataRouter) -> Self {
16584 Self
16585 }
16586 }
16587
16588 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
16589 for crate::DataRouter
16590 {
16591 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
16592 Self
16593 }
16594 }
16595
16596 #[cfg(target_os = "fuchsia")]
16597
16598 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
16599 for crate::DataRouter
16600 {
16601 fn client_compat_from(
16602 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
16603 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16604 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16605 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16606 ::fidl_next::ClientDispatcher::new(client_end)
16607 }
16608 }
16609
16610 #[cfg(target_os = "fuchsia")]
16611 pub type DictionaryProxy = ::fidl_next::Client<crate::Dictionary>;
16614
16615 impl ::fidl_next::CompatFrom<crate::Dictionary>
16616 for ::fidl_fuchsia_component_sandbox::DictionaryMarker
16617 {
16618 fn compat_from(_: crate::Dictionary) -> Self {
16619 Self
16620 }
16621 }
16622
16623 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryMarker>
16624 for crate::Dictionary
16625 {
16626 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryMarker) -> Self {
16627 Self
16628 }
16629 }
16630
16631 #[cfg(target_os = "fuchsia")]
16632
16633 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryProxy>
16634 for crate::Dictionary
16635 {
16636 fn client_compat_from(
16637 proxy: ::fidl_fuchsia_component_sandbox::DictionaryProxy,
16638 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16639 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16640 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16641 ::fidl_next::ClientDispatcher::new(client_end)
16642 }
16643 }
16644
16645 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextRequest>
16646 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
16647 {
16648 #[inline]
16649 fn compat_from(value: crate::DictionaryDrainIteratorGetNextRequest) -> Self {
16650 Self {
16651 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16652
16653 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16654 }
16655 }
16656 }
16657
16658 impl
16659 ::fidl_next::CompatFrom<
16660 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
16661 > for crate::DictionaryDrainIteratorGetNextRequest
16662 {
16663 #[inline]
16664 fn compat_from(
16665 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
16666 ) -> Self {
16667 Self {
16668 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16669
16670 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16671 }
16672 }
16673 }
16674
16675 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
16676 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
16677 {
16678 #[inline]
16679 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
16680 Self {
16681 items: ::fidl_next::CompatFrom::compat_from(value.items),
16682
16683 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16684 }
16685 }
16686 }
16687
16688 impl
16689 ::fidl_next::CompatFrom<
16690 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
16691 > for crate::DictionaryDrainIteratorGetNextResponse
16692 {
16693 #[inline]
16694 fn compat_from(
16695 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
16696 ) -> Self {
16697 Self {
16698 items: ::fidl_next::CompatFrom::compat_from(value.items),
16699
16700 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16701 }
16702 }
16703 }
16704
16705 #[cfg(target_os = "fuchsia")]
16706 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
16709
16710 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
16711 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
16712 {
16713 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
16714 Self
16715 }
16716 }
16717
16718 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
16719 for crate::DictionaryDrainIterator
16720 {
16721 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
16722 Self
16723 }
16724 }
16725
16726 #[cfg(target_os = "fuchsia")]
16727
16728 impl
16729 ::fidl_next::ClientCompatFrom<
16730 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
16731 > for crate::DictionaryDrainIterator
16732 {
16733 fn client_compat_from(
16734 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
16735 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16736 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16737 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16738 ::fidl_next::ClientDispatcher::new(client_end)
16739 }
16740 }
16741
16742 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextRequest>
16743 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
16744 {
16745 #[inline]
16746 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextRequest) -> Self {
16747 Self {
16748 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16749
16750 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16751 }
16752 }
16753 }
16754
16755 impl
16756 ::fidl_next::CompatFrom<
16757 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
16758 > for crate::DictionaryEnumerateIteratorGetNextRequest
16759 {
16760 #[inline]
16761 fn compat_from(
16762 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
16763 ) -> Self {
16764 Self {
16765 start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16766
16767 limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16768 }
16769 }
16770 }
16771
16772 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
16773 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
16774 {
16775 #[inline]
16776 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
16777 Self {
16778 key: ::fidl_next::CompatFrom::compat_from(value.key),
16779
16780 value: ::fidl_next::CompatFrom::compat_from(value.value),
16781 }
16782 }
16783 }
16784
16785 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
16786 for crate::DictionaryOptionalItem
16787 {
16788 #[inline]
16789 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
16790 Self {
16791 key: ::fidl_next::CompatFrom::compat_from(value.key),
16792
16793 value: ::fidl_next::CompatFrom::compat_from(value.value),
16794 }
16795 }
16796 }
16797
16798 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
16799 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
16800 {
16801 #[inline]
16802 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
16803 Self {
16804 items: ::fidl_next::CompatFrom::compat_from(value.items),
16805
16806 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16807 }
16808 }
16809 }
16810
16811 impl
16812 ::fidl_next::CompatFrom<
16813 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
16814 > for crate::DictionaryEnumerateIteratorGetNextResponse
16815 {
16816 #[inline]
16817 fn compat_from(
16818 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
16819 ) -> Self {
16820 Self {
16821 items: ::fidl_next::CompatFrom::compat_from(value.items),
16822
16823 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16824 }
16825 }
16826 }
16827
16828 #[cfg(target_os = "fuchsia")]
16829 pub type DictionaryEnumerateIteratorProxy =
16832 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
16833
16834 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
16835 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
16836 {
16837 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
16838 Self
16839 }
16840 }
16841
16842 impl
16843 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
16844 for crate::DictionaryEnumerateIterator
16845 {
16846 fn compat_from(
16847 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
16848 ) -> Self {
16849 Self
16850 }
16851 }
16852
16853 #[cfg(target_os = "fuchsia")]
16854
16855 impl
16856 ::fidl_next::ClientCompatFrom<
16857 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
16858 > for crate::DictionaryEnumerateIterator
16859 {
16860 fn client_compat_from(
16861 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
16862 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16863 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16864 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16865 ::fidl_next::ClientDispatcher::new(client_end)
16866 }
16867 }
16868
16869 impl ::fidl_next::CompatFrom<crate::DictionaryError>
16870 for ::fidl_fuchsia_component_sandbox::DictionaryError
16871 {
16872 fn compat_from(value: crate::DictionaryError) -> Self {
16873 match value {
16874 crate::DictionaryError::NotFound => Self::NotFound,
16875
16876 crate::DictionaryError::AlreadyExists => Self::AlreadyExists,
16877
16878 crate::DictionaryError::BadCapability => Self::BadCapability,
16879
16880 crate::DictionaryError::InvalidKey => Self::InvalidKey,
16881
16882 crate::DictionaryError::NotCloneable => Self::NotCloneable,
16883
16884 crate::DictionaryError::UnknownOrdinal_(unknown_ordinal) => {
16885 Self::__SourceBreaking { unknown_ordinal }
16886 }
16887 }
16888 }
16889 }
16890
16891 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryError>
16892 for crate::DictionaryError
16893 {
16894 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryError) -> Self {
16895 match value {
16896 ::fidl_fuchsia_component_sandbox::DictionaryError::NotFound => Self::NotFound,
16897
16898 ::fidl_fuchsia_component_sandbox::DictionaryError::AlreadyExists => {
16899 Self::AlreadyExists
16900 }
16901
16902 ::fidl_fuchsia_component_sandbox::DictionaryError::BadCapability => {
16903 Self::BadCapability
16904 }
16905
16906 ::fidl_fuchsia_component_sandbox::DictionaryError::InvalidKey => Self::InvalidKey,
16907
16908 ::fidl_fuchsia_component_sandbox::DictionaryError::NotCloneable => {
16909 Self::NotCloneable
16910 }
16911
16912 ::fidl_fuchsia_component_sandbox::DictionaryError::__SourceBreaking {
16913 unknown_ordinal: value,
16914 } => Self::UnknownOrdinal_(value),
16915 }
16916 }
16917 }
16918
16919 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
16920 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
16921 {
16922 #[inline]
16923 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
16924 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
16925 }
16926 }
16927
16928 impl
16929 ::fidl_next::CompatFrom<
16930 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
16931 > for crate::DictionaryKeysIteratorGetNextResponse
16932 {
16933 #[inline]
16934 fn compat_from(
16935 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
16936 ) -> Self {
16937 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
16938 }
16939 }
16940
16941 #[cfg(target_os = "fuchsia")]
16942 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
16945
16946 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
16947 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
16948 {
16949 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
16950 Self
16951 }
16952 }
16953
16954 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
16955 for crate::DictionaryKeysIterator
16956 {
16957 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
16958 Self
16959 }
16960 }
16961
16962 #[cfg(target_os = "fuchsia")]
16963
16964 impl
16965 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
16966 for crate::DictionaryKeysIterator
16967 {
16968 fn client_compat_from(
16969 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
16970 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16971 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16972 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16973 ::fidl_next::ClientDispatcher::new(client_end)
16974 }
16975 }
16976
16977 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
16978 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
16979 {
16980 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
16981 match value {
16982 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
16983 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
16984 }
16985
16986 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
16987 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16988 }
16989 }
16990 }
16991 }
16992
16993 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
16994 for crate::DictionaryRouterRouteResponse
16995 {
16996 fn compat_from(
16997 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
16998 ) -> Self {
16999 match value {
17000 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
17001 value,
17002 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
17003
17004 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
17005 value,
17006 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17007 }
17008 }
17009 }
17010
17011 #[cfg(target_os = "fuchsia")]
17012 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
17015
17016 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
17017 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
17018 {
17019 fn compat_from(_: crate::DictionaryRouter) -> Self {
17020 Self
17021 }
17022 }
17023
17024 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
17025 for crate::DictionaryRouter
17026 {
17027 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
17028 Self
17029 }
17030 }
17031
17032 #[cfg(target_os = "fuchsia")]
17033
17034 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
17035 for crate::DictionaryRouter
17036 {
17037 fn client_compat_from(
17038 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
17039 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17040 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17041 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17042 ::fidl_next::ClientDispatcher::new(client_end)
17043 }
17044 }
17045
17046 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
17047 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
17048 {
17049 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
17050 match value {
17051 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
17052 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
17053 }
17054
17055 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
17056 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17057 }
17058 }
17059 }
17060 }
17061
17062 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
17063 for crate::DirConnectorRouterRouteResponse
17064 {
17065 fn compat_from(
17066 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
17067 ) -> Self {
17068 match value {
17069 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
17070 value,
17071 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
17072
17073 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
17074 value,
17075 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17076 }
17077 }
17078 }
17079
17080 #[cfg(target_os = "fuchsia")]
17081 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
17084
17085 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
17086 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
17087 {
17088 fn compat_from(_: crate::DirConnectorRouter) -> Self {
17089 Self
17090 }
17091 }
17092
17093 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
17094 for crate::DirConnectorRouter
17095 {
17096 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
17097 Self
17098 }
17099 }
17100
17101 #[cfg(target_os = "fuchsia")]
17102
17103 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
17104 for crate::DirConnectorRouter
17105 {
17106 fn client_compat_from(
17107 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
17108 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17109 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17110 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17111 ::fidl_next::ClientDispatcher::new(client_end)
17112 }
17113 }
17114
17115 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
17116 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
17117 {
17118 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
17119 match value {
17120 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
17121 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
17122 }
17123
17124 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
17125 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17126 }
17127 }
17128 }
17129 }
17130
17131 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
17132 for crate::DirEntryRouterRouteResponse
17133 {
17134 fn compat_from(
17135 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
17136 ) -> Self {
17137 match value {
17138 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
17139 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
17140 }
17141
17142 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
17143 value,
17144 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17145 }
17146 }
17147 }
17148
17149 #[cfg(target_os = "fuchsia")]
17150 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
17153
17154 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
17155 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
17156 {
17157 fn compat_from(_: crate::DirEntryRouter) -> Self {
17158 Self
17159 }
17160 }
17161
17162 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
17163 for crate::DirEntryRouter
17164 {
17165 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
17166 Self
17167 }
17168 }
17169
17170 #[cfg(target_os = "fuchsia")]
17171
17172 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
17173 for crate::DirEntryRouter
17174 {
17175 fn client_compat_from(
17176 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
17177 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17178 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17179 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17180 ::fidl_next::ClientDispatcher::new(client_end)
17181 }
17182 }
17183
17184 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
17185 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
17186 {
17187 #[inline]
17188 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
17189 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17190 }
17191 }
17192
17193 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
17194 for crate::DirReceiverReceiveRequest
17195 {
17196 #[inline]
17197 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
17198 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17199 }
17200 }
17201
17202 #[cfg(target_os = "fuchsia")]
17203 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
17206
17207 impl ::fidl_next::CompatFrom<crate::DirReceiver>
17208 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
17209 {
17210 fn compat_from(_: crate::DirReceiver) -> Self {
17211 Self
17212 }
17213 }
17214
17215 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
17216 for crate::DirReceiver
17217 {
17218 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
17219 Self
17220 }
17221 }
17222
17223 #[cfg(target_os = "fuchsia")]
17224
17225 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
17226 for crate::DirReceiver
17227 {
17228 fn client_compat_from(
17229 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
17230 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17231 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17232 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17233 ::fidl_next::ClientDispatcher::new(client_end)
17234 }
17235 }
17236
17237 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
17238 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
17239 {
17240 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
17241 match value {
17242 crate::DirectoryRouterRouteResponse::Directory(value) => {
17243 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
17244 }
17245
17246 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
17247 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17248 }
17249 }
17250 }
17251 }
17252
17253 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
17254 for crate::DirectoryRouterRouteResponse
17255 {
17256 fn compat_from(
17257 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
17258 ) -> Self {
17259 match value {
17260 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
17261 value,
17262 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
17263
17264 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
17265 value,
17266 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17267 }
17268 }
17269 }
17270
17271 #[cfg(target_os = "fuchsia")]
17272 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
17275
17276 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
17277 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
17278 {
17279 fn compat_from(_: crate::DirectoryRouter) -> Self {
17280 Self
17281 }
17282 }
17283
17284 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
17285 for crate::DirectoryRouter
17286 {
17287 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
17288 Self
17289 }
17290 }
17291
17292 #[cfg(target_os = "fuchsia")]
17293
17294 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
17295 for crate::DirectoryRouter
17296 {
17297 fn client_compat_from(
17298 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
17299 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17300 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17301 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17302 ::fidl_next::ClientDispatcher::new(client_end)
17303 }
17304 }
17305
17306 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
17307 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
17308 {
17309 #[inline]
17310 fn compat_from(value: crate::ProtocolPayload) -> Self {
17311 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17312 }
17313 }
17314
17315 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
17316 for crate::ProtocolPayload
17317 {
17318 #[inline]
17319 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
17320 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17321 }
17322 }
17323
17324 #[cfg(target_os = "fuchsia")]
17325 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
17328
17329 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
17330 fn compat_from(_: crate::Receiver) -> Self {
17331 Self
17332 }
17333 }
17334
17335 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
17336 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
17337 Self
17338 }
17339 }
17340
17341 #[cfg(target_os = "fuchsia")]
17342
17343 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
17344 for crate::Receiver
17345 {
17346 fn client_compat_from(
17347 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
17348 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17349 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17350 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17351 ::fidl_next::ClientDispatcher::new(client_end)
17352 }
17353 }
17354
17355 impl ::fidl_next::CompatFrom<crate::Unavailable> for ::fidl_fuchsia_component_sandbox::Unavailable {
17356 #[inline]
17357 fn compat_from(value: crate::Unavailable) -> Self {
17358 Self {}
17359 }
17360 }
17361
17362 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unavailable> for crate::Unavailable {
17363 #[inline]
17364 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unavailable) -> Self {
17365 Self {}
17366 }
17367 }
17368}