1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_component_sandbox::natural::*;
8
9 #[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
10 pub type Token = ::fidl_next::fuchsia::zx::EventPair;
11
12 #[derive(PartialEq, Debug)]
13 #[repr(C)]
14 pub struct DictionaryRef {
15 pub token: ::fidl_next::fuchsia::zx::EventPair,
16 }
17
18 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef
19 where
20 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
21 ___E: ::fidl_next::fuchsia::HandleEncoder,
22 {
23 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DictionaryRef> = unsafe {
24 ::fidl_next::CopyOptimization::enable_if(
25 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
26 ::fidl_next::fuchsia::WireEventPair,
27 ___E,
28 >>::COPY_OPTIMIZATION
29 .is_enabled(),
30 )
31 };
32
33 #[inline]
34 fn encode(
35 self,
36 encoder_: &mut ___E,
37 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
38 _: (),
39 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
40 ::fidl_next::munge! {
41 let crate::wire::DictionaryRef {
42 token,
43
44 } = out_;
45 }
46
47 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
48
49 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
50
51 Ok(())
52 }
53 }
54
55 unsafe impl<___E>
56 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::DictionaryRef>, ___E>
57 for DictionaryRef
58 where
59 ___E: ::fidl_next::Encoder + ?Sized,
60 DictionaryRef: ::fidl_next::Encode<crate::wire::DictionaryRef, ___E>,
61 {
62 #[inline]
63 fn encode_option(
64 this: ::core::option::Option<Self>,
65 encoder: &mut ___E,
66 out: &mut ::core::mem::MaybeUninit<
67 ::fidl_next::WireBox<'static, crate::wire::DictionaryRef>,
68 >,
69 _: (),
70 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
71 if let Some(inner) = this {
72 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
73 ::fidl_next::WireBox::encode_present(out);
74 } else {
75 ::fidl_next::WireBox::encode_absent(out);
76 }
77
78 Ok(())
79 }
80 }
81
82 impl ::fidl_next::FromWire<crate::wire::DictionaryRef> for DictionaryRef {
83 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DictionaryRef, Self> = unsafe {
84 ::fidl_next::CopyOptimization::enable_if(
85 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
86 ::fidl_next::fuchsia::WireEventPair,
87 >>::COPY_OPTIMIZATION
88 .is_enabled(),
89 )
90 };
91
92 #[inline]
93 fn from_wire(wire: crate::wire::DictionaryRef) -> Self {
94 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
95 }
96 }
97
98 #[derive(PartialEq, Debug)]
99 #[repr(C)]
100 pub struct Connector {
101 pub token: ::fidl_next::fuchsia::zx::EventPair,
102 }
103
104 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector
105 where
106 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
107 ___E: ::fidl_next::fuchsia::HandleEncoder,
108 {
109 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Connector> = unsafe {
110 ::fidl_next::CopyOptimization::enable_if(
111 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
112 ::fidl_next::fuchsia::WireEventPair,
113 ___E,
114 >>::COPY_OPTIMIZATION
115 .is_enabled(),
116 )
117 };
118
119 #[inline]
120 fn encode(
121 self,
122 encoder_: &mut ___E,
123 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
124 _: (),
125 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
126 ::fidl_next::munge! {
127 let crate::wire::Connector {
128 token,
129
130 } = out_;
131 }
132
133 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
134
135 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
136
137 Ok(())
138 }
139 }
140
141 unsafe impl<___E>
142 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Connector>, ___E>
143 for Connector
144 where
145 ___E: ::fidl_next::Encoder + ?Sized,
146 Connector: ::fidl_next::Encode<crate::wire::Connector, ___E>,
147 {
148 #[inline]
149 fn encode_option(
150 this: ::core::option::Option<Self>,
151 encoder: &mut ___E,
152 out: &mut ::core::mem::MaybeUninit<
153 ::fidl_next::WireBox<'static, crate::wire::Connector>,
154 >,
155 _: (),
156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
157 if let Some(inner) = this {
158 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
159 ::fidl_next::WireBox::encode_present(out);
160 } else {
161 ::fidl_next::WireBox::encode_absent(out);
162 }
163
164 Ok(())
165 }
166 }
167
168 impl ::fidl_next::FromWire<crate::wire::Connector> for Connector {
169 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Connector, Self> = unsafe {
170 ::fidl_next::CopyOptimization::enable_if(
171 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
172 ::fidl_next::fuchsia::WireEventPair,
173 >>::COPY_OPTIMIZATION
174 .is_enabled(),
175 )
176 };
177
178 #[inline]
179 fn from_wire(wire: crate::wire::Connector) -> Self {
180 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
181 }
182 }
183
184 #[derive(PartialEq, Debug)]
185 #[repr(C)]
186 pub struct DirConnector {
187 pub token: ::fidl_next::fuchsia::zx::EventPair,
188 }
189
190 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector
191 where
192 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
193 ___E: ::fidl_next::fuchsia::HandleEncoder,
194 {
195 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirConnector> = unsafe {
196 ::fidl_next::CopyOptimization::enable_if(
197 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
198 ::fidl_next::fuchsia::WireEventPair,
199 ___E,
200 >>::COPY_OPTIMIZATION
201 .is_enabled(),
202 )
203 };
204
205 #[inline]
206 fn encode(
207 self,
208 encoder_: &mut ___E,
209 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
210 _: (),
211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
212 ::fidl_next::munge! {
213 let crate::wire::DirConnector {
214 token,
215
216 } = out_;
217 }
218
219 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
220
221 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
222
223 Ok(())
224 }
225 }
226
227 unsafe impl<___E>
228 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::DirConnector>, ___E>
229 for DirConnector
230 where
231 ___E: ::fidl_next::Encoder + ?Sized,
232 DirConnector: ::fidl_next::Encode<crate::wire::DirConnector, ___E>,
233 {
234 #[inline]
235 fn encode_option(
236 this: ::core::option::Option<Self>,
237 encoder: &mut ___E,
238 out: &mut ::core::mem::MaybeUninit<
239 ::fidl_next::WireBox<'static, crate::wire::DirConnector>,
240 >,
241 _: (),
242 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
243 if let Some(inner) = this {
244 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
245 ::fidl_next::WireBox::encode_present(out);
246 } else {
247 ::fidl_next::WireBox::encode_absent(out);
248 }
249
250 Ok(())
251 }
252 }
253
254 impl ::fidl_next::FromWire<crate::wire::DirConnector> for DirConnector {
255 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirConnector, Self> = unsafe {
256 ::fidl_next::CopyOptimization::enable_if(
257 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
258 ::fidl_next::fuchsia::WireEventPair,
259 >>::COPY_OPTIMIZATION
260 .is_enabled(),
261 )
262 };
263
264 #[inline]
265 fn from_wire(wire: crate::wire::DirConnector) -> Self {
266 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
267 }
268 }
269
270 #[derive(PartialEq, Debug)]
271 #[repr(C)]
272 pub struct DirEntry {
273 pub token: ::fidl_next::fuchsia::zx::EventPair,
274 }
275
276 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry
277 where
278 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
279 ___E: ::fidl_next::fuchsia::HandleEncoder,
280 {
281 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirEntry> = unsafe {
282 ::fidl_next::CopyOptimization::enable_if(
283 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
284 ::fidl_next::fuchsia::WireEventPair,
285 ___E,
286 >>::COPY_OPTIMIZATION
287 .is_enabled(),
288 )
289 };
290
291 #[inline]
292 fn encode(
293 self,
294 encoder_: &mut ___E,
295 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
296 _: (),
297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
298 ::fidl_next::munge! {
299 let crate::wire::DirEntry {
300 token,
301
302 } = out_;
303 }
304
305 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
306
307 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
308
309 Ok(())
310 }
311 }
312
313 unsafe impl<___E>
314 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::DirEntry>, ___E>
315 for DirEntry
316 where
317 ___E: ::fidl_next::Encoder + ?Sized,
318 DirEntry: ::fidl_next::Encode<crate::wire::DirEntry, ___E>,
319 {
320 #[inline]
321 fn encode_option(
322 this: ::core::option::Option<Self>,
323 encoder: &mut ___E,
324 out: &mut ::core::mem::MaybeUninit<
325 ::fidl_next::WireBox<'static, crate::wire::DirEntry>,
326 >,
327 _: (),
328 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
329 if let Some(inner) = this {
330 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
331 ::fidl_next::WireBox::encode_present(out);
332 } else {
333 ::fidl_next::WireBox::encode_absent(out);
334 }
335
336 Ok(())
337 }
338 }
339
340 impl ::fidl_next::FromWire<crate::wire::DirEntry> for DirEntry {
341 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirEntry, Self> = unsafe {
342 ::fidl_next::CopyOptimization::enable_if(
343 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
344 ::fidl_next::fuchsia::WireEventPair,
345 >>::COPY_OPTIMIZATION
346 .is_enabled(),
347 )
348 };
349
350 #[inline]
351 fn from_wire(wire: crate::wire::DirEntry) -> Self {
352 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
353 }
354 }
355
356 #[derive(PartialEq, Debug)]
357 pub enum Capability {
358 Unit(crate::natural::Unit),
359
360 Handle(::fidl_next::fuchsia::zx::Handle),
361
362 Data(crate::natural::Data),
363
364 Dictionary(crate::natural::DictionaryRef),
365
366 Connector(crate::natural::Connector),
367
368 DirConnector(crate::natural::DirConnector),
369
370 Directory(
371 ::fidl_next::ClientEnd<
372 ::fidl_next_fuchsia_io::Directory,
373 ::fidl_next::fuchsia::zx::Channel,
374 >,
375 ),
376
377 DirEntry(crate::natural::DirEntry),
378
379 ConnectorRouter(
380 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
381 ),
382
383 DictionaryRouter(
384 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
385 ),
386
387 DirEntryRouter(
388 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
389 ),
390
391 DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
392
393 DirConnectorRouter(
394 ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
395 ),
396
397 UnknownOrdinal_(u64),
398 }
399
400 impl Capability {
401 pub fn is_unknown(&self) -> bool {
402 #[allow(unreachable_patterns)]
403 match self {
404 Self::UnknownOrdinal_(_) => true,
405 _ => false,
406 }
407 }
408 }
409
410 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability<'static>, ___E> for Capability
411 where
412 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
413 ___E: ::fidl_next::Encoder,
414 ___E: ::fidl_next::fuchsia::HandleEncoder,
415 {
416 #[inline]
417 fn encode(
418 self,
419 encoder: &mut ___E,
420 out: &mut ::core::mem::MaybeUninit<crate::wire::Capability<'static>>,
421 _: (),
422 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
423 ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);
424
425 match self {
426 Self::Unit(value) => {
427 ::fidl_next::RawWireUnion::encode_as::<___E, crate::wire::Unit>(
428 value,
429 1,
430 encoder,
431 raw,
432 (),
433 )?
434 }
435
436 Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
437 ___E,
438 ::fidl_next::fuchsia::WireHandle,
439 >(value, 2, encoder, raw, ())?,
440
441 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
442 ___E,
443 crate::wire::Data<'static>,
444 >(value, 3, encoder, raw, ())?,
445
446 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
447 ___E,
448 crate::wire::DictionaryRef,
449 >(value, 4, encoder, raw, ())?,
450
451 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as::<
452 ___E,
453 crate::wire::Connector,
454 >(value, 5, encoder, raw, ())?,
455
456 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
457 ___E,
458 crate::wire::DirConnector,
459 >(value, 6, encoder, raw, ())?,
460
461 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
462 ___E,
463 ::fidl_next::ClientEnd<
464 ::fidl_next_fuchsia_io::Directory,
465 ::fidl_next::fuchsia::WireChannel,
466 >,
467 >(value, 7, encoder, raw, ())?,
468
469 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<
470 ___E,
471 crate::wire::DirEntry,
472 >(value, 8, encoder, raw, ())?,
473
474 Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
475 ___E,
476 ::fidl_next::ClientEnd<
477 crate::ConnectorRouter,
478 ::fidl_next::fuchsia::WireChannel,
479 >,
480 >(value, 9, encoder, raw, ())?,
481
482 Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
483 ___E,
484 ::fidl_next::ClientEnd<
485 crate::DictionaryRouter,
486 ::fidl_next::fuchsia::WireChannel,
487 >,
488 >(value, 10, encoder, raw, ())?,
489
490 Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
491 ___E,
492 ::fidl_next::ClientEnd<
493 crate::DirEntryRouter,
494 ::fidl_next::fuchsia::WireChannel,
495 >,
496 >(value, 11, encoder, raw, ())?,
497
498 Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
499 ___E,
500 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
501 >(value, 12, encoder, raw, ())?,
502
503 Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
504 ___E,
505 ::fidl_next::ClientEnd<
506 crate::DirConnectorRouter,
507 ::fidl_next::fuchsia::WireChannel,
508 >,
509 >(value, 13, encoder, raw, ())?,
510
511 Self::UnknownOrdinal_(ordinal) => {
512 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
513 }
514 }
515
516 Ok(())
517 }
518 }
519
520 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Capability<'static>, ___E>
521 for Capability
522 where
523 ___E: ?Sized,
524 Capability: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
525 {
526 #[inline]
527 fn encode_option(
528 this: ::core::option::Option<Self>,
529 encoder: &mut ___E,
530 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Capability<'static>>,
531 _: (),
532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
533 ::fidl_next::munge!(let crate::wire_optional::Capability { raw, _phantom: _ } = &mut *out);
534
535 if let Some(inner) = this {
536 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
537 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
538 } else {
539 ::fidl_next::RawWireUnion::encode_absent(raw);
540 }
541
542 Ok(())
543 }
544 }
545
546 impl<'de> ::fidl_next::FromWire<crate::wire::Capability<'de>> for Capability {
547 #[inline]
548 fn from_wire(wire: crate::wire::Capability<'de>) -> Self {
549 let wire = ::core::mem::ManuallyDrop::new(wire);
550 match wire.raw.ordinal() {
551 1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
552 wire.raw.get().read_unchecked::<crate::wire::Unit>()
553 })),
554
555 2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
556 wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
557 })),
558
559 3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
560 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
561 })),
562
563 4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
564 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
565 })),
566
567 5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
568 wire.raw.get().read_unchecked::<crate::wire::Connector>()
569 })),
570
571 6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
572 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
573 })),
574
575 7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
576 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
577 ::fidl_next_fuchsia_io::Directory,
578 ::fidl_next::fuchsia::WireChannel,
579 >>()
580 })),
581
582 8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
583 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
584 })),
585
586 9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
587 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
588 crate::ConnectorRouter,
589 ::fidl_next::fuchsia::WireChannel,
590 >>()
591 })),
592
593 10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
594 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
595 crate::DictionaryRouter,
596 ::fidl_next::fuchsia::WireChannel,
597 >>()
598 })),
599
600 11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
601 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
602 crate::DirEntryRouter,
603 ::fidl_next::fuchsia::WireChannel,
604 >>()
605 })),
606
607 12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
608 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
609 })),
610
611 13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
612 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
613 crate::DirConnectorRouter,
614 ::fidl_next::fuchsia::WireChannel,
615 >>()
616 })),
617
618 ord => return Self::UnknownOrdinal_(ord as u64),
619 }
620 }
621 }
622
623 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Capability {
624 #[inline]
625 fn from_wire_option(
626 wire: crate::wire_optional::Capability<'de>,
627 ) -> ::core::option::Option<Self> {
628 if let Some(inner) = wire.into_option() {
629 Some(::fidl_next::FromWire::from_wire(inner))
630 } else {
631 None
632 }
633 }
634 }
635
636 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
637 #[inline]
638 fn from_wire_option(
639 wire: crate::wire_optional::Capability<'de>,
640 ) -> ::core::option::Option<Self> {
641 <
642 Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
643 >::from_wire_option(wire).map(Box::new)
644 }
645 }
646
647 #[derive(PartialEq, Debug)]
648 pub struct CapabilityStoreConnectorCreateRequest {
649 pub id: u64,
650
651 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
652 }
653
654 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
655 for CapabilityStoreConnectorCreateRequest
656 where
657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
658 ___E: ::fidl_next::fuchsia::HandleEncoder,
659 {
660 #[inline]
661 fn encode(
662 self,
663 encoder_: &mut ___E,
664 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
665 _: (),
666 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
667 ::fidl_next::munge! {
668 let crate::wire::CapabilityStoreConnectorCreateRequest {
669 id,
670 receiver,
671
672 } = out_;
673 }
674
675 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
676
677 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
678
679 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
680
681 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
682
683 Ok(())
684 }
685 }
686
687 unsafe impl<___E>
688 ::fidl_next::EncodeOption<
689 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
690 ___E,
691 > for CapabilityStoreConnectorCreateRequest
692 where
693 ___E: ::fidl_next::Encoder + ?Sized,
694 CapabilityStoreConnectorCreateRequest:
695 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>,
696 {
697 #[inline]
698 fn encode_option(
699 this: ::core::option::Option<Self>,
700 encoder: &mut ___E,
701 out: &mut ::core::mem::MaybeUninit<
702 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
703 >,
704 _: (),
705 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
706 if let Some(inner) = this {
707 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
708 ::fidl_next::WireBox::encode_present(out);
709 } else {
710 ::fidl_next::WireBox::encode_absent(out);
711 }
712
713 Ok(())
714 }
715 }
716
717 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateRequest>
718 for CapabilityStoreConnectorCreateRequest
719 {
720 #[inline]
721 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateRequest) -> Self {
722 Self {
723 id: ::fidl_next::FromWire::from_wire(wire.id),
724
725 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
726 }
727 }
728 }
729
730 #[derive(PartialEq, Debug)]
731 pub struct CapabilityStoreConnectorOpenRequest {
732 pub id: u64,
733
734 pub server_end: ::fidl_next::fuchsia::zx::Channel,
735 }
736
737 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
738 for CapabilityStoreConnectorOpenRequest
739 where
740 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
741 ___E: ::fidl_next::fuchsia::HandleEncoder,
742 {
743 #[inline]
744 fn encode(
745 self,
746 encoder_: &mut ___E,
747 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
748 _: (),
749 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
750 ::fidl_next::munge! {
751 let crate::wire::CapabilityStoreConnectorOpenRequest {
752 id,
753 server_end,
754
755 } = out_;
756 }
757
758 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
759
760 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
761
762 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
763
764 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
765
766 Ok(())
767 }
768 }
769
770 unsafe impl<___E>
771 ::fidl_next::EncodeOption<
772 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
773 ___E,
774 > for CapabilityStoreConnectorOpenRequest
775 where
776 ___E: ::fidl_next::Encoder + ?Sized,
777 CapabilityStoreConnectorOpenRequest:
778 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>,
779 {
780 #[inline]
781 fn encode_option(
782 this: ::core::option::Option<Self>,
783 encoder: &mut ___E,
784 out: &mut ::core::mem::MaybeUninit<
785 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
786 >,
787 _: (),
788 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
789 if let Some(inner) = this {
790 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
791 ::fidl_next::WireBox::encode_present(out);
792 } else {
793 ::fidl_next::WireBox::encode_absent(out);
794 }
795
796 Ok(())
797 }
798 }
799
800 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenRequest>
801 for CapabilityStoreConnectorOpenRequest
802 {
803 #[inline]
804 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenRequest) -> Self {
805 Self {
806 id: ::fidl_next::FromWire::from_wire(wire.id),
807
808 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
809 }
810 }
811 }
812
813 #[derive(PartialEq, Debug)]
814 pub struct CapabilityStoreDictionaryLegacyImportRequest {
815 pub id: u64,
816
817 pub client_end: ::fidl_next::fuchsia::zx::Channel,
818 }
819
820 unsafe impl<___E>
821 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
822 for CapabilityStoreDictionaryLegacyImportRequest
823 where
824 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
825 ___E: ::fidl_next::fuchsia::HandleEncoder,
826 {
827 #[inline]
828 fn encode(
829 self,
830 encoder_: &mut ___E,
831 out_: &mut ::core::mem::MaybeUninit<
832 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
833 >,
834 _: (),
835 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
836 ::fidl_next::munge! {
837 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
838 id,
839 client_end,
840
841 } = out_;
842 }
843
844 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
845
846 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
847
848 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
849
850 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
851
852 Ok(())
853 }
854 }
855
856 unsafe impl<___E>
857 ::fidl_next::EncodeOption<
858 ::fidl_next::WireBox<
859 'static,
860 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
861 >,
862 ___E,
863 > for CapabilityStoreDictionaryLegacyImportRequest
864 where
865 ___E: ::fidl_next::Encoder + ?Sized,
866 CapabilityStoreDictionaryLegacyImportRequest:
867 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>,
868 {
869 #[inline]
870 fn encode_option(
871 this: ::core::option::Option<Self>,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<
874 ::fidl_next::WireBox<
875 'static,
876 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
877 >,
878 >,
879 _: (),
880 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
881 if let Some(inner) = this {
882 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
883 ::fidl_next::WireBox::encode_present(out);
884 } else {
885 ::fidl_next::WireBox::encode_absent(out);
886 }
887
888 Ok(())
889 }
890 }
891
892 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
893 for CapabilityStoreDictionaryLegacyImportRequest
894 {
895 #[inline]
896 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
897 Self {
898 id: ::fidl_next::FromWire::from_wire(wire.id),
899
900 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
901 }
902 }
903 }
904
905 #[derive(PartialEq, Debug)]
906 pub struct CapabilityStoreDictionaryLegacyExportRequest {
907 pub id: u64,
908
909 pub server_end: ::fidl_next::fuchsia::zx::Channel,
910 }
911
912 unsafe impl<___E>
913 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
914 for CapabilityStoreDictionaryLegacyExportRequest
915 where
916 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
917 ___E: ::fidl_next::fuchsia::HandleEncoder,
918 {
919 #[inline]
920 fn encode(
921 self,
922 encoder_: &mut ___E,
923 out_: &mut ::core::mem::MaybeUninit<
924 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
925 >,
926 _: (),
927 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
928 ::fidl_next::munge! {
929 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
930 id,
931 server_end,
932
933 } = out_;
934 }
935
936 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
937
938 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
939
940 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
941
942 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
943
944 Ok(())
945 }
946 }
947
948 unsafe impl<___E>
949 ::fidl_next::EncodeOption<
950 ::fidl_next::WireBox<
951 'static,
952 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
953 >,
954 ___E,
955 > for CapabilityStoreDictionaryLegacyExportRequest
956 where
957 ___E: ::fidl_next::Encoder + ?Sized,
958 CapabilityStoreDictionaryLegacyExportRequest:
959 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>,
960 {
961 #[inline]
962 fn encode_option(
963 this: ::core::option::Option<Self>,
964 encoder: &mut ___E,
965 out: &mut ::core::mem::MaybeUninit<
966 ::fidl_next::WireBox<
967 'static,
968 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
969 >,
970 >,
971 _: (),
972 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
973 if let Some(inner) = this {
974 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
975 ::fidl_next::WireBox::encode_present(out);
976 } else {
977 ::fidl_next::WireBox::encode_absent(out);
978 }
979
980 Ok(())
981 }
982 }
983
984 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
985 for CapabilityStoreDictionaryLegacyExportRequest
986 {
987 #[inline]
988 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
989 Self {
990 id: ::fidl_next::FromWire::from_wire(wire.id),
991
992 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
993 }
994 }
995 }
996
997 #[derive(PartialEq, Debug)]
998 pub struct CapabilityStoreDictionaryKeysRequest {
999 pub id: u64,
1000
1001 pub iterator: ::fidl_next::ServerEnd<
1002 crate::DictionaryKeysIterator,
1003 ::fidl_next::fuchsia::zx::Channel,
1004 >,
1005 }
1006
1007 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
1008 for CapabilityStoreDictionaryKeysRequest
1009 where
1010 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1011 ___E: ::fidl_next::fuchsia::HandleEncoder,
1012 {
1013 #[inline]
1014 fn encode(
1015 self,
1016 encoder_: &mut ___E,
1017 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
1018 _: (),
1019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1020 ::fidl_next::munge! {
1021 let crate::wire::CapabilityStoreDictionaryKeysRequest {
1022 id,
1023 iterator,
1024
1025 } = out_;
1026 }
1027
1028 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1029
1030 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1031
1032 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1033
1034 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1035
1036 Ok(())
1037 }
1038 }
1039
1040 unsafe impl<___E>
1041 ::fidl_next::EncodeOption<
1042 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1043 ___E,
1044 > for CapabilityStoreDictionaryKeysRequest
1045 where
1046 ___E: ::fidl_next::Encoder + ?Sized,
1047 CapabilityStoreDictionaryKeysRequest:
1048 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>,
1049 {
1050 #[inline]
1051 fn encode_option(
1052 this: ::core::option::Option<Self>,
1053 encoder: &mut ___E,
1054 out: &mut ::core::mem::MaybeUninit<
1055 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1056 >,
1057 _: (),
1058 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1059 if let Some(inner) = this {
1060 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1061 ::fidl_next::WireBox::encode_present(out);
1062 } else {
1063 ::fidl_next::WireBox::encode_absent(out);
1064 }
1065
1066 Ok(())
1067 }
1068 }
1069
1070 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
1071 for CapabilityStoreDictionaryKeysRequest
1072 {
1073 #[inline]
1074 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
1075 Self {
1076 id: ::fidl_next::FromWire::from_wire(wire.id),
1077
1078 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1079 }
1080 }
1081 }
1082
1083 #[derive(PartialEq, Debug)]
1084 pub struct CapabilityStoreDictionaryEnumerateRequest {
1085 pub id: u64,
1086
1087 pub iterator: ::fidl_next::ServerEnd<
1088 crate::DictionaryEnumerateIterator,
1089 ::fidl_next::fuchsia::zx::Channel,
1090 >,
1091 }
1092
1093 unsafe impl<___E>
1094 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
1095 for CapabilityStoreDictionaryEnumerateRequest
1096 where
1097 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1098 ___E: ::fidl_next::fuchsia::HandleEncoder,
1099 {
1100 #[inline]
1101 fn encode(
1102 self,
1103 encoder_: &mut ___E,
1104 out_: &mut ::core::mem::MaybeUninit<
1105 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1106 >,
1107 _: (),
1108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1109 ::fidl_next::munge! {
1110 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
1111 id,
1112 iterator,
1113
1114 } = out_;
1115 }
1116
1117 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1118
1119 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1120
1121 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1122
1123 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1124
1125 Ok(())
1126 }
1127 }
1128
1129 unsafe impl<___E>
1130 ::fidl_next::EncodeOption<
1131 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>,
1132 ___E,
1133 > for CapabilityStoreDictionaryEnumerateRequest
1134 where
1135 ___E: ::fidl_next::Encoder + ?Sized,
1136 CapabilityStoreDictionaryEnumerateRequest:
1137 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>,
1138 {
1139 #[inline]
1140 fn encode_option(
1141 this: ::core::option::Option<Self>,
1142 encoder: &mut ___E,
1143 out: &mut ::core::mem::MaybeUninit<
1144 ::fidl_next::WireBox<
1145 'static,
1146 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1147 >,
1148 >,
1149 _: (),
1150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1151 if let Some(inner) = this {
1152 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1153 ::fidl_next::WireBox::encode_present(out);
1154 } else {
1155 ::fidl_next::WireBox::encode_absent(out);
1156 }
1157
1158 Ok(())
1159 }
1160 }
1161
1162 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
1163 for CapabilityStoreDictionaryEnumerateRequest
1164 {
1165 #[inline]
1166 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
1167 Self {
1168 id: ::fidl_next::FromWire::from_wire(wire.id),
1169
1170 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1171 }
1172 }
1173 }
1174
1175 #[derive(PartialEq, Debug)]
1176 pub struct CapabilityStoreDictionaryDrainRequest {
1177 pub id: u64,
1178
1179 pub iterator: ::core::option::Option<
1180 ::fidl_next::ServerEnd<
1181 crate::DictionaryDrainIterator,
1182 ::fidl_next::fuchsia::zx::Channel,
1183 >,
1184 >,
1185 }
1186
1187 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
1188 for CapabilityStoreDictionaryDrainRequest
1189 where
1190 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1191 ___E: ::fidl_next::fuchsia::HandleEncoder,
1192 {
1193 #[inline]
1194 fn encode(
1195 self,
1196 encoder_: &mut ___E,
1197 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
1198 _: (),
1199 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1200 ::fidl_next::munge! {
1201 let crate::wire::CapabilityStoreDictionaryDrainRequest {
1202 id,
1203 iterator,
1204
1205 } = out_;
1206 }
1207
1208 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1209
1210 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1211
1212 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1213
1214 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1215
1216 Ok(())
1217 }
1218 }
1219
1220 unsafe impl<___E>
1221 ::fidl_next::EncodeOption<
1222 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1223 ___E,
1224 > for CapabilityStoreDictionaryDrainRequest
1225 where
1226 ___E: ::fidl_next::Encoder + ?Sized,
1227 CapabilityStoreDictionaryDrainRequest:
1228 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>,
1229 {
1230 #[inline]
1231 fn encode_option(
1232 this: ::core::option::Option<Self>,
1233 encoder: &mut ___E,
1234 out: &mut ::core::mem::MaybeUninit<
1235 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1236 >,
1237 _: (),
1238 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1239 if let Some(inner) = this {
1240 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1241 ::fidl_next::WireBox::encode_present(out);
1242 } else {
1243 ::fidl_next::WireBox::encode_absent(out);
1244 }
1245
1246 Ok(())
1247 }
1248 }
1249
1250 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
1251 for CapabilityStoreDictionaryDrainRequest
1252 {
1253 #[inline]
1254 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
1255 Self {
1256 id: ::fidl_next::FromWire::from_wire(wire.id),
1257
1258 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1259 }
1260 }
1261 }
1262
1263 #[derive(PartialEq, Debug)]
1264 pub struct CapabilityStoreExportResponse {
1265 pub capability: crate::natural::Capability,
1266 }
1267
1268 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
1269 for CapabilityStoreExportResponse
1270 where
1271 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1272 ___E: ::fidl_next::Encoder,
1273 ___E: ::fidl_next::fuchsia::HandleEncoder,
1274 {
1275 #[inline]
1276 fn encode(
1277 self,
1278 encoder_: &mut ___E,
1279 out_: &mut ::core::mem::MaybeUninit<
1280 crate::wire::CapabilityStoreExportResponse<'static>,
1281 >,
1282 _: (),
1283 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1284 ::fidl_next::munge! {
1285 let crate::wire::CapabilityStoreExportResponse {
1286 capability,
1287
1288 } = out_;
1289 }
1290
1291 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1292
1293 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1294
1295 Ok(())
1296 }
1297 }
1298
1299 unsafe impl<___E>
1300 ::fidl_next::EncodeOption<
1301 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1302 ___E,
1303 > for CapabilityStoreExportResponse
1304 where
1305 ___E: ::fidl_next::Encoder + ?Sized,
1306 CapabilityStoreExportResponse:
1307 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>,
1308 {
1309 #[inline]
1310 fn encode_option(
1311 this: ::core::option::Option<Self>,
1312 encoder: &mut ___E,
1313 out: &mut ::core::mem::MaybeUninit<
1314 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1315 >,
1316 _: (),
1317 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1318 if let Some(inner) = this {
1319 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1320 ::fidl_next::WireBox::encode_present(out);
1321 } else {
1322 ::fidl_next::WireBox::encode_absent(out);
1323 }
1324
1325 Ok(())
1326 }
1327 }
1328
1329 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
1330 for CapabilityStoreExportResponse
1331 {
1332 #[inline]
1333 fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
1334 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
1335 }
1336 }
1337
1338 #[derive(PartialEq, Debug)]
1339 pub struct CapabilityStoreImportRequest {
1340 pub id: u64,
1341
1342 pub capability: crate::natural::Capability,
1343 }
1344
1345 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
1346 for CapabilityStoreImportRequest
1347 where
1348 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1349 ___E: ::fidl_next::Encoder,
1350 ___E: ::fidl_next::fuchsia::HandleEncoder,
1351 {
1352 #[inline]
1353 fn encode(
1354 self,
1355 encoder_: &mut ___E,
1356 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
1357 _: (),
1358 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1359 ::fidl_next::munge! {
1360 let crate::wire::CapabilityStoreImportRequest {
1361 id,
1362 capability,
1363
1364 } = out_;
1365 }
1366
1367 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1368
1369 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1370
1371 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1372
1373 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1374
1375 Ok(())
1376 }
1377 }
1378
1379 unsafe impl<___E>
1380 ::fidl_next::EncodeOption<
1381 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1382 ___E,
1383 > for CapabilityStoreImportRequest
1384 where
1385 ___E: ::fidl_next::Encoder + ?Sized,
1386 CapabilityStoreImportRequest:
1387 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>,
1388 {
1389 #[inline]
1390 fn encode_option(
1391 this: ::core::option::Option<Self>,
1392 encoder: &mut ___E,
1393 out: &mut ::core::mem::MaybeUninit<
1394 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1395 >,
1396 _: (),
1397 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1398 if let Some(inner) = this {
1399 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1400 ::fidl_next::WireBox::encode_present(out);
1401 } else {
1402 ::fidl_next::WireBox::encode_absent(out);
1403 }
1404
1405 Ok(())
1406 }
1407 }
1408
1409 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
1410 for CapabilityStoreImportRequest
1411 {
1412 #[inline]
1413 fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
1414 Self {
1415 id: ::fidl_next::FromWire::from_wire(wire.id),
1416
1417 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1418 }
1419 }
1420 }
1421
1422 #[derive(PartialEq, Debug)]
1423 pub struct CapabilityStoreDirConnectorCreateRequest {
1424 pub id: u64,
1425
1426 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
1427 }
1428
1429 unsafe impl<___E>
1430 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
1431 for CapabilityStoreDirConnectorCreateRequest
1432 where
1433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1434 ___E: ::fidl_next::fuchsia::HandleEncoder,
1435 {
1436 #[inline]
1437 fn encode(
1438 self,
1439 encoder_: &mut ___E,
1440 out_: &mut ::core::mem::MaybeUninit<
1441 crate::wire::CapabilityStoreDirConnectorCreateRequest,
1442 >,
1443 _: (),
1444 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1445 ::fidl_next::munge! {
1446 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
1447 id,
1448 receiver,
1449
1450 } = out_;
1451 }
1452
1453 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1454
1455 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1456
1457 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
1458
1459 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
1460
1461 Ok(())
1462 }
1463 }
1464
1465 unsafe impl<___E>
1466 ::fidl_next::EncodeOption<
1467 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>,
1468 ___E,
1469 > for CapabilityStoreDirConnectorCreateRequest
1470 where
1471 ___E: ::fidl_next::Encoder + ?Sized,
1472 CapabilityStoreDirConnectorCreateRequest:
1473 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>,
1474 {
1475 #[inline]
1476 fn encode_option(
1477 this: ::core::option::Option<Self>,
1478 encoder: &mut ___E,
1479 out: &mut ::core::mem::MaybeUninit<
1480 ::fidl_next::WireBox<
1481 'static,
1482 crate::wire::CapabilityStoreDirConnectorCreateRequest,
1483 >,
1484 >,
1485 _: (),
1486 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1487 if let Some(inner) = this {
1488 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1489 ::fidl_next::WireBox::encode_present(out);
1490 } else {
1491 ::fidl_next::WireBox::encode_absent(out);
1492 }
1493
1494 Ok(())
1495 }
1496 }
1497
1498 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
1499 for CapabilityStoreDirConnectorCreateRequest
1500 {
1501 #[inline]
1502 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
1503 Self {
1504 id: ::fidl_next::FromWire::from_wire(wire.id),
1505
1506 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
1507 }
1508 }
1509 }
1510
1511 #[derive(PartialEq, Debug)]
1512 pub struct CapabilityStoreDirConnectorOpenRequest {
1513 pub id: u64,
1514
1515 pub server_end: ::fidl_next::ServerEnd<
1516 ::fidl_next_fuchsia_io::Directory,
1517 ::fidl_next::fuchsia::zx::Channel,
1518 >,
1519 }
1520
1521 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest, ___E>
1522 for CapabilityStoreDirConnectorOpenRequest
1523 where
1524 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1525 ___E: ::fidl_next::fuchsia::HandleEncoder,
1526 {
1527 #[inline]
1528 fn encode(
1529 self,
1530 encoder_: &mut ___E,
1531 out_: &mut ::core::mem::MaybeUninit<
1532 crate::wire::CapabilityStoreDirConnectorOpenRequest,
1533 >,
1534 _: (),
1535 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1536 ::fidl_next::munge! {
1537 let crate::wire::CapabilityStoreDirConnectorOpenRequest {
1538 id,
1539 server_end,
1540
1541 } = out_;
1542 }
1543
1544 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1545
1546 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1547
1548 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
1549
1550 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
1551
1552 Ok(())
1553 }
1554 }
1555
1556 unsafe impl<___E>
1557 ::fidl_next::EncodeOption<
1558 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenRequest>,
1559 ___E,
1560 > for CapabilityStoreDirConnectorOpenRequest
1561 where
1562 ___E: ::fidl_next::Encoder + ?Sized,
1563 CapabilityStoreDirConnectorOpenRequest:
1564 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest, ___E>,
1565 {
1566 #[inline]
1567 fn encode_option(
1568 this: ::core::option::Option<Self>,
1569 encoder: &mut ___E,
1570 out: &mut ::core::mem::MaybeUninit<
1571 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenRequest>,
1572 >,
1573 _: (),
1574 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1575 if let Some(inner) = this {
1576 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1577 ::fidl_next::WireBox::encode_present(out);
1578 } else {
1579 ::fidl_next::WireBox::encode_absent(out);
1580 }
1581
1582 Ok(())
1583 }
1584 }
1585
1586 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest>
1587 for CapabilityStoreDirConnectorOpenRequest
1588 {
1589 #[inline]
1590 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenRequest) -> Self {
1591 Self {
1592 id: ::fidl_next::FromWire::from_wire(wire.id),
1593
1594 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
1595 }
1596 }
1597 }
1598
1599 #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
1600 #[derive(PartialEq, Debug)]
1601 #[repr(C)]
1602 pub struct InstanceToken {
1603 pub token: ::fidl_next::fuchsia::zx::EventPair,
1604 }
1605
1606 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken
1607 where
1608 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1609 ___E: ::fidl_next::fuchsia::HandleEncoder,
1610 {
1611 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
1612 ::fidl_next::CopyOptimization::enable_if(
1613 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
1614 ::fidl_next::fuchsia::WireEventPair,
1615 ___E,
1616 >>::COPY_OPTIMIZATION
1617 .is_enabled(),
1618 )
1619 };
1620
1621 #[inline]
1622 fn encode(
1623 self,
1624 encoder_: &mut ___E,
1625 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
1626 _: (),
1627 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1628 ::fidl_next::munge! {
1629 let crate::wire::InstanceToken {
1630 token,
1631
1632 } = out_;
1633 }
1634
1635 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
1636
1637 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
1638
1639 Ok(())
1640 }
1641 }
1642
1643 unsafe impl<___E>
1644 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::InstanceToken>, ___E>
1645 for InstanceToken
1646 where
1647 ___E: ::fidl_next::Encoder + ?Sized,
1648 InstanceToken: ::fidl_next::Encode<crate::wire::InstanceToken, ___E>,
1649 {
1650 #[inline]
1651 fn encode_option(
1652 this: ::core::option::Option<Self>,
1653 encoder: &mut ___E,
1654 out: &mut ::core::mem::MaybeUninit<
1655 ::fidl_next::WireBox<'static, crate::wire::InstanceToken>,
1656 >,
1657 _: (),
1658 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1659 if let Some(inner) = this {
1660 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1661 ::fidl_next::WireBox::encode_present(out);
1662 } else {
1663 ::fidl_next::WireBox::encode_absent(out);
1664 }
1665
1666 Ok(())
1667 }
1668 }
1669
1670 impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
1671 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
1672 ::fidl_next::CopyOptimization::enable_if(
1673 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1674 ::fidl_next::fuchsia::WireEventPair,
1675 >>::COPY_OPTIMIZATION
1676 .is_enabled(),
1677 )
1678 };
1679
1680 #[inline]
1681 fn from_wire(wire: crate::wire::InstanceToken) -> Self {
1682 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1683 }
1684 }
1685
1686 #[doc = " A request for a route.\n"]
1687 #[derive(PartialEq, Debug, Default)]
1688 pub struct RouteRequest {
1689 pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
1690
1691 pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
1692 }
1693
1694 impl RouteRequest {
1695 fn __max_ordinal(&self) -> usize {
1696 if self.metadata.is_some() {
1697 return 2;
1698 }
1699
1700 if self.requesting.is_some() {
1701 return 1;
1702 }
1703
1704 0
1705 }
1706 }
1707
1708 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouteRequest<'static>, ___E> for RouteRequest
1709 where
1710 ___E: ::fidl_next::Encoder + ?Sized,
1711 ___E: ::fidl_next::fuchsia::HandleEncoder,
1712 {
1713 #[inline]
1714 fn encode(
1715 mut self,
1716 encoder: &mut ___E,
1717 out: &mut ::core::mem::MaybeUninit<crate::wire::RouteRequest<'static>>,
1718 _: (),
1719 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1720 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
1721
1722 let max_ord = self.__max_ordinal();
1723
1724 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
1725 ::fidl_next::Wire::zero_padding(&mut out);
1726
1727 let mut preallocated =
1728 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
1729
1730 for i in 1..=max_ord {
1731 match i {
1732 2 => {
1733 if let Some(value) = self.metadata.take() {
1734 ::fidl_next::WireEnvelope::encode_value::<
1735 crate::wire::DictionaryRef,
1736 ___E,
1737 >(
1738 value, preallocated.encoder, &mut out, ()
1739 )?;
1740 } else {
1741 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1742 }
1743 }
1744
1745 1 => {
1746 if let Some(value) = self.requesting.take() {
1747 ::fidl_next::WireEnvelope::encode_value::<
1748 crate::wire::InstanceToken,
1749 ___E,
1750 >(
1751 value, preallocated.encoder, &mut out, ()
1752 )?;
1753 } else {
1754 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1755 }
1756 }
1757
1758 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
1759 }
1760 unsafe {
1761 preallocated.write_next(out.assume_init_ref());
1762 }
1763 }
1764
1765 ::fidl_next::WireTable::encode_len(table, max_ord);
1766
1767 Ok(())
1768 }
1769 }
1770
1771 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
1772 #[inline]
1773 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
1774 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1775
1776 let requesting = wire_.table.get(1);
1777
1778 let metadata = wire_.table.get(2);
1779
1780 Self {
1781 requesting: requesting.map(|envelope| {
1782 ::fidl_next::FromWire::from_wire(unsafe {
1783 envelope.read_unchecked::<crate::wire::InstanceToken>()
1784 })
1785 }),
1786
1787 metadata: metadata.map(|envelope| {
1788 ::fidl_next::FromWire::from_wire(unsafe {
1789 envelope.read_unchecked::<crate::wire::DictionaryRef>()
1790 })
1791 }),
1792 }
1793 }
1794 }
1795
1796 #[derive(PartialEq, Debug)]
1797 pub enum ConnectorRouterRouteResponse {
1798 Connector(crate::natural::Connector),
1799
1800 Unavailable(crate::natural::Unit),
1801 }
1802
1803 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>
1804 for ConnectorRouterRouteResponse
1805 where
1806 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1807 ___E: ::fidl_next::fuchsia::HandleEncoder,
1808 {
1809 #[inline]
1810 fn encode(
1811 self,
1812 encoder: &mut ___E,
1813 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectorRouterRouteResponse>,
1814 _: (),
1815 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1816 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
1817
1818 match self {
1819 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
1820 ___E,
1821 crate::wire::Connector,
1822 >(value, 1, encoder, raw, ())?,
1823
1824 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
1825 ___E,
1826 crate::wire::Unit,
1827 >(value, 2, encoder, raw, ())?,
1828 }
1829
1830 Ok(())
1831 }
1832 }
1833
1834 unsafe impl<___E>
1835 ::fidl_next::EncodeOption<crate::wire_optional::ConnectorRouterRouteResponse, ___E>
1836 for ConnectorRouterRouteResponse
1837 where
1838 ___E: ?Sized,
1839 ConnectorRouterRouteResponse:
1840 ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>,
1841 {
1842 #[inline]
1843 fn encode_option(
1844 this: ::core::option::Option<Self>,
1845 encoder: &mut ___E,
1846 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConnectorRouterRouteResponse>,
1847 _: (),
1848 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1849 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
1850
1851 if let Some(inner) = this {
1852 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1853 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1854 } else {
1855 ::fidl_next::RawWireUnion::encode_absent(raw);
1856 }
1857
1858 Ok(())
1859 }
1860 }
1861
1862 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
1863 for ConnectorRouterRouteResponse
1864 {
1865 #[inline]
1866 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
1867 let wire = ::core::mem::ManuallyDrop::new(wire);
1868 match wire.raw.ordinal() {
1869 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1870 wire.raw.get().read_unchecked::<crate::wire::Connector>()
1871 })),
1872
1873 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
1874 wire.raw.get().read_unchecked::<crate::wire::Unit>()
1875 })),
1876
1877 _ => unsafe { ::core::hint::unreachable_unchecked() },
1878 }
1879 }
1880 }
1881
1882 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
1883 for ConnectorRouterRouteResponse
1884 {
1885 #[inline]
1886 fn from_wire_option(
1887 wire: crate::wire_optional::ConnectorRouterRouteResponse,
1888 ) -> ::core::option::Option<Self> {
1889 if let Some(inner) = wire.into_option() {
1890 Some(::fidl_next::FromWire::from_wire(inner))
1891 } else {
1892 None
1893 }
1894 }
1895 }
1896
1897 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
1898 for Box<ConnectorRouterRouteResponse>
1899 {
1900 #[inline]
1901 fn from_wire_option(
1902 wire: crate::wire_optional::ConnectorRouterRouteResponse,
1903 ) -> ::core::option::Option<Self> {
1904 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
1905 crate::wire_optional::ConnectorRouterRouteResponse,
1906 >>::from_wire_option(wire)
1907 .map(Box::new)
1908 }
1909 }
1910
1911 #[derive(PartialEq, Debug)]
1912 pub enum DataRouterRouteResponse {
1913 Data(crate::natural::Data),
1914
1915 Unavailable(crate::natural::Unit),
1916 }
1917
1918 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>
1919 for DataRouterRouteResponse
1920 where
1921 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1922 ___E: ::fidl_next::Encoder,
1923 ___E: ::fidl_next::fuchsia::HandleEncoder,
1924 {
1925 #[inline]
1926 fn encode(
1927 self,
1928 encoder: &mut ___E,
1929 out: &mut ::core::mem::MaybeUninit<crate::wire::DataRouterRouteResponse<'static>>,
1930 _: (),
1931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1932 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
1933
1934 match self {
1935 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
1936 ___E,
1937 crate::wire::Data<'static>,
1938 >(value, 1, encoder, raw, ())?,
1939
1940 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as::<
1941 ___E,
1942 crate::wire::Unit,
1943 >(value, 2, encoder, raw, ())?,
1944 }
1945
1946 Ok(())
1947 }
1948 }
1949
1950 unsafe impl<___E>
1951 ::fidl_next::EncodeOption<crate::wire_optional::DataRouterRouteResponse<'static>, ___E>
1952 for DataRouterRouteResponse
1953 where
1954 ___E: ?Sized,
1955 DataRouterRouteResponse:
1956 ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>,
1957 {
1958 #[inline]
1959 fn encode_option(
1960 this: ::core::option::Option<Self>,
1961 encoder: &mut ___E,
1962 out: &mut ::core::mem::MaybeUninit<
1963 crate::wire_optional::DataRouterRouteResponse<'static>,
1964 >,
1965 _: (),
1966 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1967 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
1968
1969 if let Some(inner) = this {
1970 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1971 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1972 } else {
1973 ::fidl_next::RawWireUnion::encode_absent(raw);
1974 }
1975
1976 Ok(())
1977 }
1978 }
1979
1980 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
1981 for DataRouterRouteResponse
1982 {
1983 #[inline]
1984 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
1985 let wire = ::core::mem::ManuallyDrop::new(wire);
1986 match wire.raw.ordinal() {
1987 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
1988 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
1989 })),
1990
1991 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
1992 wire.raw.get().read_unchecked::<crate::wire::Unit>()
1993 })),
1994
1995 _ => unsafe { ::core::hint::unreachable_unchecked() },
1996 }
1997 }
1998 }
1999
2000 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2001 for DataRouterRouteResponse
2002 {
2003 #[inline]
2004 fn from_wire_option(
2005 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2006 ) -> ::core::option::Option<Self> {
2007 if let Some(inner) = wire.into_option() {
2008 Some(::fidl_next::FromWire::from_wire(inner))
2009 } else {
2010 None
2011 }
2012 }
2013 }
2014
2015 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2016 for Box<DataRouterRouteResponse>
2017 {
2018 #[inline]
2019 fn from_wire_option(
2020 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2021 ) -> ::core::option::Option<Self> {
2022 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
2023 crate::wire_optional::DataRouterRouteResponse<'de>,
2024 >>::from_wire_option(wire)
2025 .map(Box::new)
2026 }
2027 }
2028
2029 #[derive(PartialEq, Debug)]
2030 pub struct DictionaryDrainIteratorGetNextResponse {
2031 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
2032
2033 pub end_id: u64,
2034 }
2035
2036 unsafe impl<___E>
2037 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
2038 for DictionaryDrainIteratorGetNextResponse
2039 where
2040 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2041 ___E: ::fidl_next::Encoder,
2042 ___E: ::fidl_next::fuchsia::HandleEncoder,
2043 {
2044 #[inline]
2045 fn encode(
2046 self,
2047 encoder_: &mut ___E,
2048 out_: &mut ::core::mem::MaybeUninit<
2049 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2050 >,
2051 _: (),
2052 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2053 ::fidl_next::munge! {
2054 let crate::wire::DictionaryDrainIteratorGetNextResponse {
2055 items,
2056 end_id,
2057
2058 } = out_;
2059 }
2060
2061 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2062
2063 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2064 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2065
2066 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2067
2068 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2069
2070 Ok(())
2071 }
2072 }
2073
2074 unsafe impl<___E>
2075 ::fidl_next::EncodeOption<
2076 ::fidl_next::WireBox<
2077 'static,
2078 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2079 >,
2080 ___E,
2081 > for DictionaryDrainIteratorGetNextResponse
2082 where
2083 ___E: ::fidl_next::Encoder + ?Sized,
2084 DictionaryDrainIteratorGetNextResponse:
2085 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>,
2086 {
2087 #[inline]
2088 fn encode_option(
2089 this: ::core::option::Option<Self>,
2090 encoder: &mut ___E,
2091 out: &mut ::core::mem::MaybeUninit<
2092 ::fidl_next::WireBox<
2093 'static,
2094 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2095 >,
2096 >,
2097 _: (),
2098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2099 if let Some(inner) = this {
2100 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2101 ::fidl_next::WireBox::encode_present(out);
2102 } else {
2103 ::fidl_next::WireBox::encode_absent(out);
2104 }
2105
2106 Ok(())
2107 }
2108 }
2109
2110 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
2111 for DictionaryDrainIteratorGetNextResponse
2112 {
2113 #[inline]
2114 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
2115 Self {
2116 items: ::fidl_next::FromWire::from_wire(wire.items),
2117
2118 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2119 }
2120 }
2121 }
2122
2123 #[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"]
2124 #[derive(PartialEq, Debug)]
2125 pub struct DictionaryOptionalItem {
2126 pub key: ::std::string::String,
2127
2128 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
2129 }
2130
2131 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
2132 for DictionaryOptionalItem
2133 where
2134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2135 ___E: ::fidl_next::Encoder,
2136 ___E: ::fidl_next::fuchsia::HandleEncoder,
2137 {
2138 #[inline]
2139 fn encode(
2140 self,
2141 encoder_: &mut ___E,
2142 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
2143 _: (),
2144 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2145 ::fidl_next::munge! {
2146 let crate::wire::DictionaryOptionalItem {
2147 key,
2148 value,
2149
2150 } = out_;
2151 }
2152
2153 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2154
2155 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2156 ::fidl_next::Constrained::validate(_field, 255)?;
2157
2158 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2159
2160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2161
2162 Ok(())
2163 }
2164 }
2165
2166 unsafe impl<___E>
2167 ::fidl_next::EncodeOption<
2168 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2169 ___E,
2170 > for DictionaryOptionalItem
2171 where
2172 ___E: ::fidl_next::Encoder + ?Sized,
2173 DictionaryOptionalItem:
2174 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>,
2175 {
2176 #[inline]
2177 fn encode_option(
2178 this: ::core::option::Option<Self>,
2179 encoder: &mut ___E,
2180 out: &mut ::core::mem::MaybeUninit<
2181 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2182 >,
2183 _: (),
2184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2185 if let Some(inner) = this {
2186 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2187 ::fidl_next::WireBox::encode_present(out);
2188 } else {
2189 ::fidl_next::WireBox::encode_absent(out);
2190 }
2191
2192 Ok(())
2193 }
2194 }
2195
2196 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
2197 for DictionaryOptionalItem
2198 {
2199 #[inline]
2200 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
2201 Self {
2202 key: ::fidl_next::FromWire::from_wire(wire.key),
2203
2204 value: ::fidl_next::FromWire::from_wire(wire.value),
2205 }
2206 }
2207 }
2208
2209 #[derive(PartialEq, Debug)]
2210 pub struct DictionaryEnumerateIteratorGetNextResponse {
2211 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
2212
2213 pub end_id: u64,
2214 }
2215
2216 unsafe impl<___E>
2217 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
2218 for DictionaryEnumerateIteratorGetNextResponse
2219 where
2220 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2221 ___E: ::fidl_next::Encoder,
2222 ___E: ::fidl_next::fuchsia::HandleEncoder,
2223 {
2224 #[inline]
2225 fn encode(
2226 self,
2227 encoder_: &mut ___E,
2228 out_: &mut ::core::mem::MaybeUninit<
2229 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2230 >,
2231 _: (),
2232 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2233 ::fidl_next::munge! {
2234 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
2235 items,
2236 end_id,
2237
2238 } = out_;
2239 }
2240
2241 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2242
2243 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2244 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2245
2246 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2247
2248 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2249
2250 Ok(())
2251 }
2252 }
2253
2254 unsafe impl<___E>
2255 ::fidl_next::EncodeOption<
2256 ::fidl_next::WireBox<
2257 'static,
2258 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2259 >,
2260 ___E,
2261 > for DictionaryEnumerateIteratorGetNextResponse
2262 where
2263 ___E: ::fidl_next::Encoder + ?Sized,
2264 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<
2265 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2266 ___E,
2267 >,
2268 {
2269 #[inline]
2270 fn encode_option(
2271 this: ::core::option::Option<Self>,
2272 encoder: &mut ___E,
2273 out: &mut ::core::mem::MaybeUninit<
2274 ::fidl_next::WireBox<
2275 'static,
2276 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2277 >,
2278 >,
2279 _: (),
2280 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2281 if let Some(inner) = this {
2282 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2283 ::fidl_next::WireBox::encode_present(out);
2284 } else {
2285 ::fidl_next::WireBox::encode_absent(out);
2286 }
2287
2288 Ok(())
2289 }
2290 }
2291
2292 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
2293 for DictionaryEnumerateIteratorGetNextResponse
2294 {
2295 #[inline]
2296 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
2297 Self {
2298 items: ::fidl_next::FromWire::from_wire(wire.items),
2299
2300 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2301 }
2302 }
2303 }
2304
2305 #[derive(PartialEq, Debug)]
2306 pub struct DictionaryKeysIteratorGetNextResponse {
2307 pub keys: ::std::vec::Vec<::std::string::String>,
2308 }
2309
2310 unsafe impl<___E>
2311 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
2312 for DictionaryKeysIteratorGetNextResponse
2313 where
2314 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2315 ___E: ::fidl_next::Encoder,
2316 ___E: ::fidl_next::fuchsia::HandleEncoder,
2317 {
2318 #[inline]
2319 fn encode(
2320 self,
2321 encoder_: &mut ___E,
2322 out_: &mut ::core::mem::MaybeUninit<
2323 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2324 >,
2325 _: (),
2326 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2327 ::fidl_next::munge! {
2328 let crate::wire::DictionaryKeysIteratorGetNextResponse {
2329 keys,
2330
2331 } = out_;
2332 }
2333
2334 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
2335
2336 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
2337 ::fidl_next::Constrained::validate(_field, (128, 255))?;
2338
2339 Ok(())
2340 }
2341 }
2342
2343 unsafe impl<___E>
2344 ::fidl_next::EncodeOption<
2345 ::fidl_next::WireBox<
2346 'static,
2347 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2348 >,
2349 ___E,
2350 > for DictionaryKeysIteratorGetNextResponse
2351 where
2352 ___E: ::fidl_next::Encoder + ?Sized,
2353 DictionaryKeysIteratorGetNextResponse:
2354 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>,
2355 {
2356 #[inline]
2357 fn encode_option(
2358 this: ::core::option::Option<Self>,
2359 encoder: &mut ___E,
2360 out: &mut ::core::mem::MaybeUninit<
2361 ::fidl_next::WireBox<
2362 'static,
2363 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2364 >,
2365 >,
2366 _: (),
2367 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2368 if let Some(inner) = this {
2369 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2370 ::fidl_next::WireBox::encode_present(out);
2371 } else {
2372 ::fidl_next::WireBox::encode_absent(out);
2373 }
2374
2375 Ok(())
2376 }
2377 }
2378
2379 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
2380 for DictionaryKeysIteratorGetNextResponse
2381 {
2382 #[inline]
2383 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
2384 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
2385 }
2386 }
2387
2388 #[derive(PartialEq, Debug)]
2389 pub enum DictionaryRouterRouteResponse {
2390 Dictionary(crate::natural::DictionaryRef),
2391
2392 Unavailable(crate::natural::Unit),
2393 }
2394
2395 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>
2396 for DictionaryRouterRouteResponse
2397 where
2398 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2399 ___E: ::fidl_next::fuchsia::HandleEncoder,
2400 {
2401 #[inline]
2402 fn encode(
2403 self,
2404 encoder: &mut ___E,
2405 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRouterRouteResponse>,
2406 _: (),
2407 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2408 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
2409
2410 match self {
2411 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2412 ___E,
2413 crate::wire::DictionaryRef,
2414 >(value, 1, encoder, raw, ())?,
2415
2416 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2417 ___E,
2418 crate::wire::Unit,
2419 >(value, 2, encoder, raw, ())?,
2420 }
2421
2422 Ok(())
2423 }
2424 }
2425
2426 unsafe impl<___E>
2427 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryRouterRouteResponse, ___E>
2428 for DictionaryRouterRouteResponse
2429 where
2430 ___E: ?Sized,
2431 DictionaryRouterRouteResponse:
2432 ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>,
2433 {
2434 #[inline]
2435 fn encode_option(
2436 this: ::core::option::Option<Self>,
2437 encoder: &mut ___E,
2438 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryRouterRouteResponse>,
2439 _: (),
2440 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2441 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2442
2443 if let Some(inner) = this {
2444 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2445 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2446 } else {
2447 ::fidl_next::RawWireUnion::encode_absent(raw);
2448 }
2449
2450 Ok(())
2451 }
2452 }
2453
2454 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
2455 for DictionaryRouterRouteResponse
2456 {
2457 #[inline]
2458 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
2459 let wire = ::core::mem::ManuallyDrop::new(wire);
2460 match wire.raw.ordinal() {
2461 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
2462 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
2463 })),
2464
2465 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2466 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2467 })),
2468
2469 _ => unsafe { ::core::hint::unreachable_unchecked() },
2470 }
2471 }
2472 }
2473
2474 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2475 for DictionaryRouterRouteResponse
2476 {
2477 #[inline]
2478 fn from_wire_option(
2479 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2480 ) -> ::core::option::Option<Self> {
2481 if let Some(inner) = wire.into_option() {
2482 Some(::fidl_next::FromWire::from_wire(inner))
2483 } else {
2484 None
2485 }
2486 }
2487 }
2488
2489 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2490 for Box<DictionaryRouterRouteResponse>
2491 {
2492 #[inline]
2493 fn from_wire_option(
2494 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2495 ) -> ::core::option::Option<Self> {
2496 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
2497 crate::wire_optional::DictionaryRouterRouteResponse,
2498 >>::from_wire_option(wire)
2499 .map(Box::new)
2500 }
2501 }
2502
2503 #[derive(PartialEq, Debug)]
2504 pub enum DirConnectorRouterRouteResponse {
2505 DirConnector(crate::natural::DirConnector),
2506
2507 Unavailable(crate::natural::Unit),
2508 }
2509
2510 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>
2511 for DirConnectorRouterRouteResponse
2512 where
2513 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2514 ___E: ::fidl_next::fuchsia::HandleEncoder,
2515 {
2516 #[inline]
2517 fn encode(
2518 self,
2519 encoder: &mut ___E,
2520 out: &mut ::core::mem::MaybeUninit<crate::wire::DirConnectorRouterRouteResponse>,
2521 _: (),
2522 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2523 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2524
2525 match self {
2526 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2527 ___E,
2528 crate::wire::DirConnector,
2529 >(value, 1, encoder, raw, ())?,
2530
2531 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2532 ___E,
2533 crate::wire::Unit,
2534 >(value, 2, encoder, raw, ())?,
2535 }
2536
2537 Ok(())
2538 }
2539 }
2540
2541 unsafe impl<___E>
2542 ::fidl_next::EncodeOption<crate::wire_optional::DirConnectorRouterRouteResponse, ___E>
2543 for DirConnectorRouterRouteResponse
2544 where
2545 ___E: ?Sized,
2546 DirConnectorRouterRouteResponse:
2547 ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>,
2548 {
2549 #[inline]
2550 fn encode_option(
2551 this: ::core::option::Option<Self>,
2552 encoder: &mut ___E,
2553 out: &mut ::core::mem::MaybeUninit<
2554 crate::wire_optional::DirConnectorRouterRouteResponse,
2555 >,
2556 _: (),
2557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2558 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2559
2560 if let Some(inner) = this {
2561 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2562 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2563 } else {
2564 ::fidl_next::RawWireUnion::encode_absent(raw);
2565 }
2566
2567 Ok(())
2568 }
2569 }
2570
2571 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
2572 for DirConnectorRouterRouteResponse
2573 {
2574 #[inline]
2575 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
2576 let wire = ::core::mem::ManuallyDrop::new(wire);
2577 match wire.raw.ordinal() {
2578 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
2579 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
2580 })),
2581
2582 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2583 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2584 })),
2585
2586 _ => unsafe { ::core::hint::unreachable_unchecked() },
2587 }
2588 }
2589 }
2590
2591 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
2592 for DirConnectorRouterRouteResponse
2593 {
2594 #[inline]
2595 fn from_wire_option(
2596 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
2597 ) -> ::core::option::Option<Self> {
2598 if let Some(inner) = wire.into_option() {
2599 Some(::fidl_next::FromWire::from_wire(inner))
2600 } else {
2601 None
2602 }
2603 }
2604 }
2605
2606 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
2607 for Box<DirConnectorRouterRouteResponse>
2608 {
2609 #[inline]
2610 fn from_wire_option(
2611 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
2612 ) -> ::core::option::Option<Self> {
2613 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
2614 crate::wire_optional::DirConnectorRouterRouteResponse,
2615 >>::from_wire_option(wire)
2616 .map(Box::new)
2617 }
2618 }
2619
2620 #[derive(PartialEq, Debug)]
2621 pub enum DirEntryRouterRouteResponse {
2622 DirEntry(crate::natural::DirEntry),
2623
2624 Unavailable(crate::natural::Unit),
2625 }
2626
2627 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>
2628 for DirEntryRouterRouteResponse
2629 where
2630 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2631 ___E: ::fidl_next::fuchsia::HandleEncoder,
2632 {
2633 #[inline]
2634 fn encode(
2635 self,
2636 encoder: &mut ___E,
2637 out: &mut ::core::mem::MaybeUninit<crate::wire::DirEntryRouterRouteResponse>,
2638 _: (),
2639 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2640 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
2641
2642 match self {
2643 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2644 ___E,
2645 crate::wire::DirEntry,
2646 >(value, 1, encoder, raw, ())?,
2647
2648 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2649 ___E,
2650 crate::wire::Unit,
2651 >(value, 2, encoder, raw, ())?,
2652 }
2653
2654 Ok(())
2655 }
2656 }
2657
2658 unsafe impl<___E>
2659 ::fidl_next::EncodeOption<crate::wire_optional::DirEntryRouterRouteResponse, ___E>
2660 for DirEntryRouterRouteResponse
2661 where
2662 ___E: ?Sized,
2663 DirEntryRouterRouteResponse:
2664 ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>,
2665 {
2666 #[inline]
2667 fn encode_option(
2668 this: ::core::option::Option<Self>,
2669 encoder: &mut ___E,
2670 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirEntryRouterRouteResponse>,
2671 _: (),
2672 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2673 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2674
2675 if let Some(inner) = this {
2676 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2677 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2678 } else {
2679 ::fidl_next::RawWireUnion::encode_absent(raw);
2680 }
2681
2682 Ok(())
2683 }
2684 }
2685
2686 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
2687 for DirEntryRouterRouteResponse
2688 {
2689 #[inline]
2690 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
2691 let wire = ::core::mem::ManuallyDrop::new(wire);
2692 match wire.raw.ordinal() {
2693 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
2694 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
2695 })),
2696
2697 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2698 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2699 })),
2700
2701 _ => unsafe { ::core::hint::unreachable_unchecked() },
2702 }
2703 }
2704 }
2705
2706 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
2707 for DirEntryRouterRouteResponse
2708 {
2709 #[inline]
2710 fn from_wire_option(
2711 wire: crate::wire_optional::DirEntryRouterRouteResponse,
2712 ) -> ::core::option::Option<Self> {
2713 if let Some(inner) = wire.into_option() {
2714 Some(::fidl_next::FromWire::from_wire(inner))
2715 } else {
2716 None
2717 }
2718 }
2719 }
2720
2721 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
2722 for Box<DirEntryRouterRouteResponse>
2723 {
2724 #[inline]
2725 fn from_wire_option(
2726 wire: crate::wire_optional::DirEntryRouterRouteResponse,
2727 ) -> ::core::option::Option<Self> {
2728 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
2729 crate::wire_optional::DirEntryRouterRouteResponse,
2730 >>::from_wire_option(wire)
2731 .map(Box::new)
2732 }
2733 }
2734
2735 #[derive(PartialEq, Debug)]
2736 #[repr(C)]
2737 pub struct DirReceiverReceiveRequest {
2738 pub channel: ::fidl_next::ServerEnd<
2739 ::fidl_next_fuchsia_io::Directory,
2740 ::fidl_next::fuchsia::zx::Channel,
2741 >,
2742 }
2743
2744 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest, ___E>
2745 for DirReceiverReceiveRequest
2746 where
2747 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2748 ___E: ::fidl_next::fuchsia::HandleEncoder,
2749 {
2750 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2751 Self,
2752 crate::wire::DirReceiverReceiveRequest,
2753 > = unsafe {
2754 ::fidl_next::CopyOptimization::enable_if(
2755 true && <::fidl_next::ServerEnd<
2756 ::fidl_next_fuchsia_io::Directory,
2757 ::fidl_next::fuchsia::zx::Channel,
2758 > as ::fidl_next::Encode<
2759 ::fidl_next::ServerEnd<
2760 ::fidl_next_fuchsia_io::Directory,
2761 ::fidl_next::fuchsia::WireChannel,
2762 >,
2763 ___E,
2764 >>::COPY_OPTIMIZATION
2765 .is_enabled(),
2766 )
2767 };
2768
2769 #[inline]
2770 fn encode(
2771 self,
2772 encoder_: &mut ___E,
2773 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest>,
2774 _: (),
2775 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2776 ::fidl_next::munge! {
2777 let crate::wire::DirReceiverReceiveRequest {
2778 channel,
2779
2780 } = out_;
2781 }
2782
2783 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
2784
2785 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
2786
2787 Ok(())
2788 }
2789 }
2790
2791 unsafe impl<___E>
2792 ::fidl_next::EncodeOption<
2793 ::fidl_next::WireBox<'static, crate::wire::DirReceiverReceiveRequest>,
2794 ___E,
2795 > for DirReceiverReceiveRequest
2796 where
2797 ___E: ::fidl_next::Encoder + ?Sized,
2798 DirReceiverReceiveRequest:
2799 ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest, ___E>,
2800 {
2801 #[inline]
2802 fn encode_option(
2803 this: ::core::option::Option<Self>,
2804 encoder: &mut ___E,
2805 out: &mut ::core::mem::MaybeUninit<
2806 ::fidl_next::WireBox<'static, crate::wire::DirReceiverReceiveRequest>,
2807 >,
2808 _: (),
2809 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2810 if let Some(inner) = this {
2811 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2812 ::fidl_next::WireBox::encode_present(out);
2813 } else {
2814 ::fidl_next::WireBox::encode_absent(out);
2815 }
2816
2817 Ok(())
2818 }
2819 }
2820
2821 impl ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest> for DirReceiverReceiveRequest {
2822 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2823 crate::wire::DirReceiverReceiveRequest,
2824 Self,
2825 > = unsafe {
2826 ::fidl_next::CopyOptimization::enable_if(
2827 true && <::fidl_next::ServerEnd<
2828 ::fidl_next_fuchsia_io::Directory,
2829 ::fidl_next::fuchsia::zx::Channel,
2830 > as ::fidl_next::FromWire<
2831 ::fidl_next::ServerEnd<
2832 ::fidl_next_fuchsia_io::Directory,
2833 ::fidl_next::fuchsia::WireChannel,
2834 >,
2835 >>::COPY_OPTIMIZATION
2836 .is_enabled(),
2837 )
2838 };
2839
2840 #[inline]
2841 fn from_wire(wire: crate::wire::DirReceiverReceiveRequest) -> Self {
2842 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
2843 }
2844 }
2845
2846 #[derive(PartialEq, Debug)]
2847 pub enum DirectoryRouterRouteResponse {
2848 Directory(
2849 ::fidl_next::ClientEnd<
2850 ::fidl_next_fuchsia_io::Directory,
2851 ::fidl_next::fuchsia::zx::Channel,
2852 >,
2853 ),
2854
2855 Unavailable(crate::natural::Unit),
2856 }
2857
2858 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>
2859 for DirectoryRouterRouteResponse
2860 where
2861 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2862 ___E: ::fidl_next::fuchsia::HandleEncoder,
2863 {
2864 #[inline]
2865 fn encode(
2866 self,
2867 encoder: &mut ___E,
2868 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRouterRouteResponse>,
2869 _: (),
2870 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2871 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
2872
2873 match self {
2874 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2875 ___E,
2876 ::fidl_next::ClientEnd<
2877 ::fidl_next_fuchsia_io::Directory,
2878 ::fidl_next::fuchsia::WireChannel,
2879 >,
2880 >(value, 1, encoder, raw, ())?,
2881
2882 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2883 ___E,
2884 crate::wire::Unit,
2885 >(value, 2, encoder, raw, ())?,
2886 }
2887
2888 Ok(())
2889 }
2890 }
2891
2892 unsafe impl<___E>
2893 ::fidl_next::EncodeOption<crate::wire_optional::DirectoryRouterRouteResponse, ___E>
2894 for DirectoryRouterRouteResponse
2895 where
2896 ___E: ?Sized,
2897 DirectoryRouterRouteResponse:
2898 ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>,
2899 {
2900 #[inline]
2901 fn encode_option(
2902 this: ::core::option::Option<Self>,
2903 encoder: &mut ___E,
2904 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirectoryRouterRouteResponse>,
2905 _: (),
2906 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2907 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2908
2909 if let Some(inner) = this {
2910 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2911 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2912 } else {
2913 ::fidl_next::RawWireUnion::encode_absent(raw);
2914 }
2915
2916 Ok(())
2917 }
2918 }
2919
2920 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
2921 for DirectoryRouterRouteResponse
2922 {
2923 #[inline]
2924 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
2925 let wire = ::core::mem::ManuallyDrop::new(wire);
2926 match wire.raw.ordinal() {
2927 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2928 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
2929 ::fidl_next_fuchsia_io::Directory,
2930 ::fidl_next::fuchsia::WireChannel,
2931 >>()
2932 })),
2933
2934 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2935 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2936 })),
2937
2938 _ => unsafe { ::core::hint::unreachable_unchecked() },
2939 }
2940 }
2941 }
2942
2943 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
2944 for DirectoryRouterRouteResponse
2945 {
2946 #[inline]
2947 fn from_wire_option(
2948 wire: crate::wire_optional::DirectoryRouterRouteResponse,
2949 ) -> ::core::option::Option<Self> {
2950 if let Some(inner) = wire.into_option() {
2951 Some(::fidl_next::FromWire::from_wire(inner))
2952 } else {
2953 None
2954 }
2955 }
2956 }
2957
2958 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
2959 for Box<DirectoryRouterRouteResponse>
2960 {
2961 #[inline]
2962 fn from_wire_option(
2963 wire: crate::wire_optional::DirectoryRouterRouteResponse,
2964 ) -> ::core::option::Option<Self> {
2965 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
2966 crate::wire_optional::DirectoryRouterRouteResponse,
2967 >>::from_wire_option(wire)
2968 .map(Box::new)
2969 }
2970 }
2971
2972 #[doc = " Contains a protocol open request.\n"]
2973 #[derive(PartialEq, Debug)]
2974 #[repr(C)]
2975 pub struct ProtocolPayload {
2976 pub channel: ::fidl_next::fuchsia::zx::Channel,
2977 }
2978
2979 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E> for ProtocolPayload
2980 where
2981 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2982 ___E: ::fidl_next::fuchsia::HandleEncoder,
2983 {
2984 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
2985 ::fidl_next::CopyOptimization::enable_if(
2986 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
2987 ::fidl_next::fuchsia::WireChannel,
2988 ___E,
2989 >>::COPY_OPTIMIZATION
2990 .is_enabled(),
2991 )
2992 };
2993
2994 #[inline]
2995 fn encode(
2996 self,
2997 encoder_: &mut ___E,
2998 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
2999 _: (),
3000 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3001 ::fidl_next::munge! {
3002 let crate::wire::ProtocolPayload {
3003 channel,
3004
3005 } = out_;
3006 }
3007
3008 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3009
3010 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3011
3012 Ok(())
3013 }
3014 }
3015
3016 unsafe impl<___E>
3017 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>, ___E>
3018 for ProtocolPayload
3019 where
3020 ___E: ::fidl_next::Encoder + ?Sized,
3021 ProtocolPayload: ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>,
3022 {
3023 #[inline]
3024 fn encode_option(
3025 this: ::core::option::Option<Self>,
3026 encoder: &mut ___E,
3027 out: &mut ::core::mem::MaybeUninit<
3028 ::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>,
3029 >,
3030 _: (),
3031 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3032 if let Some(inner) = this {
3033 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3034 ::fidl_next::WireBox::encode_present(out);
3035 } else {
3036 ::fidl_next::WireBox::encode_absent(out);
3037 }
3038
3039 Ok(())
3040 }
3041 }
3042
3043 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
3044 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
3045 ::fidl_next::CopyOptimization::enable_if(
3046 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3047 ::fidl_next::fuchsia::WireChannel,
3048 >>::COPY_OPTIMIZATION
3049 .is_enabled(),
3050 )
3051 };
3052
3053 #[inline]
3054 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
3055 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
3056 }
3057 }
3058}
3059
3060pub mod wire {
3061
3062 pub use fidl_next_common_fuchsia_component_sandbox::wire::*;
3063
3064 pub type Token = ::fidl_next::fuchsia::WireEventPair;
3066
3067 #[derive(Debug)]
3069 #[repr(C)]
3070 pub struct DictionaryRef {
3071 pub token: ::fidl_next::fuchsia::WireEventPair,
3072 }
3073
3074 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
3075 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
3076
3077 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
3078
3079 unsafe impl ::fidl_next::Wire for DictionaryRef {
3080 type Owned<'de> = DictionaryRef;
3081
3082 #[inline]
3083 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3084 ::fidl_next::munge! {
3085 let Self {
3086
3087 token,
3088
3089 } = &mut *out_;
3090 }
3091
3092 ::fidl_next::Wire::zero_padding(token);
3093 }
3094 }
3095
3096 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
3097 where
3098 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3099 ___D: ::fidl_next::fuchsia::HandleDecoder,
3100 {
3101 fn decode(
3102 slot_: ::fidl_next::Slot<'_, Self>,
3103 decoder_: &mut ___D,
3104 _: (),
3105 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3106 ::fidl_next::munge! {
3107 let Self {
3108
3109 mut token,
3110
3111 } = slot_;
3112 }
3113
3114 let _field = token.as_mut();
3115
3116 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3117
3118 Ok(())
3119 }
3120 }
3121
3122 impl ::fidl_next::IntoNatural for DictionaryRef {
3123 type Natural = crate::natural::DictionaryRef;
3124 }
3125
3126 impl ::fidl_next::Unconstrained for DictionaryRef {}
3127
3128 #[derive(Debug)]
3130 #[repr(C)]
3131 pub struct Connector {
3132 pub token: ::fidl_next::fuchsia::WireEventPair,
3133 }
3134
3135 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
3136 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
3137
3138 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
3139
3140 unsafe impl ::fidl_next::Wire for Connector {
3141 type Owned<'de> = Connector;
3142
3143 #[inline]
3144 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3145 ::fidl_next::munge! {
3146 let Self {
3147
3148 token,
3149
3150 } = &mut *out_;
3151 }
3152
3153 ::fidl_next::Wire::zero_padding(token);
3154 }
3155 }
3156
3157 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
3158 where
3159 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3160 ___D: ::fidl_next::fuchsia::HandleDecoder,
3161 {
3162 fn decode(
3163 slot_: ::fidl_next::Slot<'_, Self>,
3164 decoder_: &mut ___D,
3165 _: (),
3166 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3167 ::fidl_next::munge! {
3168 let Self {
3169
3170 mut token,
3171
3172 } = slot_;
3173 }
3174
3175 let _field = token.as_mut();
3176
3177 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3178
3179 Ok(())
3180 }
3181 }
3182
3183 impl ::fidl_next::IntoNatural for Connector {
3184 type Natural = crate::natural::Connector;
3185 }
3186
3187 impl ::fidl_next::Unconstrained for Connector {}
3188
3189 #[derive(Debug)]
3191 #[repr(C)]
3192 pub struct DirConnector {
3193 pub token: ::fidl_next::fuchsia::WireEventPair,
3194 }
3195
3196 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
3197 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
3198
3199 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
3200
3201 unsafe impl ::fidl_next::Wire for DirConnector {
3202 type Owned<'de> = DirConnector;
3203
3204 #[inline]
3205 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3206 ::fidl_next::munge! {
3207 let Self {
3208
3209 token,
3210
3211 } = &mut *out_;
3212 }
3213
3214 ::fidl_next::Wire::zero_padding(token);
3215 }
3216 }
3217
3218 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
3219 where
3220 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3221 ___D: ::fidl_next::fuchsia::HandleDecoder,
3222 {
3223 fn decode(
3224 slot_: ::fidl_next::Slot<'_, Self>,
3225 decoder_: &mut ___D,
3226 _: (),
3227 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3228 ::fidl_next::munge! {
3229 let Self {
3230
3231 mut token,
3232
3233 } = slot_;
3234 }
3235
3236 let _field = token.as_mut();
3237
3238 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3239
3240 Ok(())
3241 }
3242 }
3243
3244 impl ::fidl_next::IntoNatural for DirConnector {
3245 type Natural = crate::natural::DirConnector;
3246 }
3247
3248 impl ::fidl_next::Unconstrained for DirConnector {}
3249
3250 #[derive(Debug)]
3252 #[repr(C)]
3253 pub struct DirEntry {
3254 pub token: ::fidl_next::fuchsia::WireEventPair,
3255 }
3256
3257 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
3258 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
3259
3260 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
3261
3262 unsafe impl ::fidl_next::Wire for DirEntry {
3263 type Owned<'de> = DirEntry;
3264
3265 #[inline]
3266 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3267 ::fidl_next::munge! {
3268 let Self {
3269
3270 token,
3271
3272 } = &mut *out_;
3273 }
3274
3275 ::fidl_next::Wire::zero_padding(token);
3276 }
3277 }
3278
3279 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
3280 where
3281 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3282 ___D: ::fidl_next::fuchsia::HandleDecoder,
3283 {
3284 fn decode(
3285 slot_: ::fidl_next::Slot<'_, Self>,
3286 decoder_: &mut ___D,
3287 _: (),
3288 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3289 ::fidl_next::munge! {
3290 let Self {
3291
3292 mut token,
3293
3294 } = slot_;
3295 }
3296
3297 let _field = token.as_mut();
3298
3299 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3300
3301 Ok(())
3302 }
3303 }
3304
3305 impl ::fidl_next::IntoNatural for DirEntry {
3306 type Natural = crate::natural::DirEntry;
3307 }
3308
3309 impl ::fidl_next::Unconstrained for DirEntry {}
3310
3311 #[repr(transparent)]
3313 pub struct Capability<'de> {
3314 pub(crate) raw: ::fidl_next::RawWireUnion,
3315 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3316 }
3317
3318 impl<'de> Drop for Capability<'de> {
3319 fn drop(&mut self) {
3320 match self.raw.ordinal() {
3321 1 => {
3322 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
3323 }
3324
3325 2 => {
3326 let _ = unsafe {
3327 self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
3328 };
3329 }
3330
3331 3 => {
3332 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
3333 }
3334
3335 4 => {
3336 let _ =
3337 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
3338 }
3339
3340 5 => {
3341 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
3342 }
3343
3344 6 => {
3345 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
3346 }
3347
3348 7 => {
3349 let _ = unsafe {
3350 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3351 ::fidl_next_fuchsia_io::Directory,
3352 ::fidl_next::fuchsia::WireChannel,
3353 >>()
3354 };
3355 }
3356
3357 8 => {
3358 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
3359 }
3360
3361 9 => {
3362 let _ = unsafe {
3363 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3364 crate::ConnectorRouter,
3365 ::fidl_next::fuchsia::WireChannel,
3366 >>()
3367 };
3368 }
3369
3370 10 => {
3371 let _ = unsafe {
3372 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3373 crate::DictionaryRouter,
3374 ::fidl_next::fuchsia::WireChannel,
3375 >>()
3376 };
3377 }
3378
3379 11 => {
3380 let _ = unsafe {
3381 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3382 crate::DirEntryRouter,
3383 ::fidl_next::fuchsia::WireChannel,
3384 >>()
3385 };
3386 }
3387
3388 12 => {
3389 let _ = unsafe {
3390 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3391 crate::DataRouter,
3392 ::fidl_next::fuchsia::WireChannel,
3393 >>()
3394 };
3395 }
3396
3397 13 => {
3398 let _ = unsafe {
3399 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3400 crate::DirConnectorRouter,
3401 ::fidl_next::fuchsia::WireChannel,
3402 >>()
3403 };
3404 }
3405
3406 _ => (),
3407 }
3408 }
3409 }
3410
3411 unsafe impl ::fidl_next::Wire for Capability<'static> {
3412 type Owned<'de> = Capability<'de>;
3413
3414 #[inline]
3415 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3416 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3417 ::fidl_next::RawWireUnion::zero_padding(raw);
3418 }
3419 }
3420
3421 pub mod capability {
3422 pub enum Ref<'de> {
3423 Unit(&'de crate::wire::Unit),
3424
3425 Handle(&'de ::fidl_next::fuchsia::WireHandle),
3426
3427 Data(&'de crate::wire::Data<'de>),
3428
3429 Dictionary(&'de crate::wire::DictionaryRef),
3430
3431 Connector(&'de crate::wire::Connector),
3432
3433 DirConnector(&'de crate::wire::DirConnector),
3434
3435 Directory(
3436 &'de ::fidl_next::ClientEnd<
3437 ::fidl_next_fuchsia_io::Directory,
3438 ::fidl_next::fuchsia::WireChannel,
3439 >,
3440 ),
3441
3442 DirEntry(&'de crate::wire::DirEntry),
3443
3444 ConnectorRouter(
3445 &'de ::fidl_next::ClientEnd<
3446 crate::ConnectorRouter,
3447 ::fidl_next::fuchsia::WireChannel,
3448 >,
3449 ),
3450
3451 DictionaryRouter(
3452 &'de ::fidl_next::ClientEnd<
3453 crate::DictionaryRouter,
3454 ::fidl_next::fuchsia::WireChannel,
3455 >,
3456 ),
3457
3458 DirEntryRouter(
3459 &'de ::fidl_next::ClientEnd<
3460 crate::DirEntryRouter,
3461 ::fidl_next::fuchsia::WireChannel,
3462 >,
3463 ),
3464
3465 DataRouter(
3466 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
3467 ),
3468
3469 DirConnectorRouter(
3470 &'de ::fidl_next::ClientEnd<
3471 crate::DirConnectorRouter,
3472 ::fidl_next::fuchsia::WireChannel,
3473 >,
3474 ),
3475
3476 UnknownOrdinal_(u64),
3477 }
3478 }
3479
3480 impl<'de> Capability<'de> {
3481 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
3482 match self.raw.ordinal() {
3483 1 => crate::wire::capability::Ref::Unit(unsafe {
3484 self.raw.get().deref_unchecked::<crate::wire::Unit>()
3485 }),
3486
3487 2 => crate::wire::capability::Ref::Handle(unsafe {
3488 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
3489 }),
3490
3491 3 => crate::wire::capability::Ref::Data(unsafe {
3492 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
3493 }),
3494
3495 4 => crate::wire::capability::Ref::Dictionary(unsafe {
3496 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
3497 }),
3498
3499 5 => crate::wire::capability::Ref::Connector(unsafe {
3500 self.raw.get().deref_unchecked::<crate::wire::Connector>()
3501 }),
3502
3503 6 => crate::wire::capability::Ref::DirConnector(unsafe {
3504 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
3505 }),
3506
3507 7 => crate::wire::capability::Ref::Directory(unsafe {
3508 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3509 ::fidl_next_fuchsia_io::Directory,
3510 ::fidl_next::fuchsia::WireChannel,
3511 >>()
3512 }),
3513
3514 8 => crate::wire::capability::Ref::DirEntry(unsafe {
3515 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
3516 }),
3517
3518 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
3519 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3520 crate::ConnectorRouter,
3521 ::fidl_next::fuchsia::WireChannel,
3522 >>()
3523 }),
3524
3525 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
3526 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3527 crate::DictionaryRouter,
3528 ::fidl_next::fuchsia::WireChannel,
3529 >>()
3530 }),
3531
3532 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
3533 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3534 crate::DirEntryRouter,
3535 ::fidl_next::fuchsia::WireChannel,
3536 >>()
3537 }),
3538
3539 12 => crate::wire::capability::Ref::DataRouter(unsafe {
3540 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
3541 }),
3542
3543 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
3544 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3545 crate::DirConnectorRouter,
3546 ::fidl_next::fuchsia::WireChannel,
3547 >>()
3548 }),
3549
3550 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
3551 }
3552 }
3553 }
3554
3555 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
3556 where
3557 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3558 ___D: ::fidl_next::Decoder,
3559 ___D: ::fidl_next::fuchsia::HandleDecoder,
3560 {
3561 fn decode(
3562 mut slot: ::fidl_next::Slot<'_, Self>,
3563 decoder: &mut ___D,
3564 _: (),
3565 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3566 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3567 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
3568 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
3569 raw,
3570 decoder,
3571 (),
3572 )?,
3573
3574 2 => {
3575 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
3576 raw,
3577 decoder,
3578 (),
3579 )?
3580 }
3581
3582 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
3583 raw,
3584 decoder,
3585 (),
3586 )?,
3587
3588 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
3589 raw,
3590 decoder,
3591 (),
3592 )?,
3593
3594 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
3595 raw,
3596 decoder,
3597 (),
3598 )?,
3599
3600 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
3601 raw,
3602 decoder,
3603 (),
3604 )?,
3605
3606 7 => ::fidl_next::RawWireUnion::decode_as::<
3607 ___D,
3608 ::fidl_next::ClientEnd<
3609 ::fidl_next_fuchsia_io::Directory,
3610 ::fidl_next::fuchsia::WireChannel,
3611 >,
3612 >(raw, decoder, ())?,
3613
3614 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
3615 raw,
3616 decoder,
3617 (),
3618 )?,
3619
3620 9 => ::fidl_next::RawWireUnion::decode_as::<
3621 ___D,
3622 ::fidl_next::ClientEnd<
3623 crate::ConnectorRouter,
3624 ::fidl_next::fuchsia::WireChannel,
3625 >,
3626 >(raw, decoder, ())?,
3627
3628 10 => ::fidl_next::RawWireUnion::decode_as::<
3629 ___D,
3630 ::fidl_next::ClientEnd<
3631 crate::DictionaryRouter,
3632 ::fidl_next::fuchsia::WireChannel,
3633 >,
3634 >(raw, decoder, ())?,
3635
3636 11 => ::fidl_next::RawWireUnion::decode_as::<
3637 ___D,
3638 ::fidl_next::ClientEnd<
3639 crate::DirEntryRouter,
3640 ::fidl_next::fuchsia::WireChannel,
3641 >,
3642 >(raw, decoder, ())?,
3643
3644 12 => ::fidl_next::RawWireUnion::decode_as::<
3645 ___D,
3646 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
3647 >(raw, decoder, ())?,
3648
3649 13 => ::fidl_next::RawWireUnion::decode_as::<
3650 ___D,
3651 ::fidl_next::ClientEnd<
3652 crate::DirConnectorRouter,
3653 ::fidl_next::fuchsia::WireChannel,
3654 >,
3655 >(raw, decoder, ())?,
3656
3657 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
3658 }
3659
3660 Ok(())
3661 }
3662 }
3663
3664 impl<'de> ::core::fmt::Debug for Capability<'de> {
3665 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3666 match self.raw.ordinal() {
3667 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
3668 2 => unsafe {
3669 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
3670 },
3671 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
3672 4 => unsafe {
3673 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
3674 },
3675 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
3676 6 => unsafe {
3677 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
3678 },
3679 7 => unsafe {
3680 self.raw
3681 .get()
3682 .deref_unchecked::<::fidl_next::ClientEnd<
3683 ::fidl_next_fuchsia_io::Directory,
3684 ::fidl_next::fuchsia::WireChannel,
3685 >>()
3686 .fmt(f)
3687 },
3688 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
3689 9 => unsafe {
3690 self.raw
3691 .get()
3692 .deref_unchecked::<::fidl_next::ClientEnd<
3693 crate::ConnectorRouter,
3694 ::fidl_next::fuchsia::WireChannel,
3695 >>()
3696 .fmt(f)
3697 },
3698 10 => unsafe {
3699 self.raw
3700 .get()
3701 .deref_unchecked::<::fidl_next::ClientEnd<
3702 crate::DictionaryRouter,
3703 ::fidl_next::fuchsia::WireChannel,
3704 >>()
3705 .fmt(f)
3706 },
3707 11 => unsafe {
3708 self.raw
3709 .get()
3710 .deref_unchecked::<::fidl_next::ClientEnd<
3711 crate::DirEntryRouter,
3712 ::fidl_next::fuchsia::WireChannel,
3713 >>()
3714 .fmt(f)
3715 },
3716 12 => unsafe {
3717 self.raw.get().deref_unchecked::<
3718 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
3719 >().fmt(f)
3720 },
3721 13 => unsafe {
3722 self.raw
3723 .get()
3724 .deref_unchecked::<::fidl_next::ClientEnd<
3725 crate::DirConnectorRouter,
3726 ::fidl_next::fuchsia::WireChannel,
3727 >>()
3728 .fmt(f)
3729 },
3730 _ => unsafe { ::core::hint::unreachable_unchecked() },
3731 }
3732 }
3733 }
3734
3735 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
3736 type Natural = crate::natural::Capability;
3737 }
3738
3739 impl ::fidl_next::Unconstrained for Capability<'static> {}
3740
3741 #[derive(Debug)]
3743 #[repr(C)]
3744 pub struct CapabilityStoreConnectorCreateRequest {
3745 pub id: ::fidl_next::WireU64,
3746
3747 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
3748 }
3749
3750 static_assertions::const_assert_eq!(
3751 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
3752 16
3753 );
3754 static_assertions::const_assert_eq!(
3755 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
3756 8
3757 );
3758
3759 static_assertions::const_assert_eq!(
3760 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
3761 0
3762 );
3763
3764 static_assertions::const_assert_eq!(
3765 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
3766 8
3767 );
3768
3769 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
3770 type Owned<'de> = CapabilityStoreConnectorCreateRequest;
3771
3772 #[inline]
3773 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3774 ::fidl_next::munge! {
3775 let Self {
3776
3777 id,
3778 receiver,
3779
3780 } = &mut *out_;
3781 }
3782
3783 ::fidl_next::Wire::zero_padding(id);
3784
3785 ::fidl_next::Wire::zero_padding(receiver);
3786
3787 unsafe {
3788 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3789 }
3790 }
3791 }
3792
3793 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
3794 where
3795 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3796 ___D: ::fidl_next::fuchsia::HandleDecoder,
3797 {
3798 fn decode(
3799 slot_: ::fidl_next::Slot<'_, Self>,
3800 decoder_: &mut ___D,
3801 _: (),
3802 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3803 if slot_.as_bytes()[12..16] != [0u8; 4] {
3804 return Err(::fidl_next::DecodeError::InvalidPadding);
3805 }
3806
3807 ::fidl_next::munge! {
3808 let Self {
3809
3810 mut id,
3811 mut receiver,
3812
3813 } = slot_;
3814 }
3815
3816 let _field = id.as_mut();
3817
3818 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3819
3820 let _field = receiver.as_mut();
3821
3822 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
3823
3824 Ok(())
3825 }
3826 }
3827
3828 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
3829 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
3830 }
3831
3832 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateRequest {}
3833
3834 #[derive(Debug)]
3836 #[repr(C)]
3837 pub struct CapabilityStoreConnectorOpenRequest {
3838 pub id: ::fidl_next::WireU64,
3839
3840 pub server_end: ::fidl_next::fuchsia::WireChannel,
3841 }
3842
3843 static_assertions::const_assert_eq!(
3844 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
3845 16
3846 );
3847 static_assertions::const_assert_eq!(
3848 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
3849 8
3850 );
3851
3852 static_assertions::const_assert_eq!(
3853 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
3854 0
3855 );
3856
3857 static_assertions::const_assert_eq!(
3858 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
3859 8
3860 );
3861
3862 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
3863 type Owned<'de> = CapabilityStoreConnectorOpenRequest;
3864
3865 #[inline]
3866 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3867 ::fidl_next::munge! {
3868 let Self {
3869
3870 id,
3871 server_end,
3872
3873 } = &mut *out_;
3874 }
3875
3876 ::fidl_next::Wire::zero_padding(id);
3877
3878 ::fidl_next::Wire::zero_padding(server_end);
3879
3880 unsafe {
3881 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3882 }
3883 }
3884 }
3885
3886 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
3887 where
3888 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3889 ___D: ::fidl_next::fuchsia::HandleDecoder,
3890 {
3891 fn decode(
3892 slot_: ::fidl_next::Slot<'_, Self>,
3893 decoder_: &mut ___D,
3894 _: (),
3895 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3896 if slot_.as_bytes()[12..16] != [0u8; 4] {
3897 return Err(::fidl_next::DecodeError::InvalidPadding);
3898 }
3899
3900 ::fidl_next::munge! {
3901 let Self {
3902
3903 mut id,
3904 mut server_end,
3905
3906 } = slot_;
3907 }
3908
3909 let _field = id.as_mut();
3910
3911 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3912
3913 let _field = server_end.as_mut();
3914
3915 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
3916
3917 Ok(())
3918 }
3919 }
3920
3921 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
3922 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
3923 }
3924
3925 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenRequest {}
3926
3927 #[derive(Debug)]
3929 #[repr(C)]
3930 pub struct CapabilityStoreDictionaryLegacyImportRequest {
3931 pub id: ::fidl_next::WireU64,
3932
3933 pub client_end: ::fidl_next::fuchsia::WireChannel,
3934 }
3935
3936 static_assertions::const_assert_eq!(
3937 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
3938 16
3939 );
3940 static_assertions::const_assert_eq!(
3941 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
3942 8
3943 );
3944
3945 static_assertions::const_assert_eq!(
3946 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
3947 0
3948 );
3949
3950 static_assertions::const_assert_eq!(
3951 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
3952 8
3953 );
3954
3955 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
3956 type Owned<'de> = CapabilityStoreDictionaryLegacyImportRequest;
3957
3958 #[inline]
3959 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3960 ::fidl_next::munge! {
3961 let Self {
3962
3963 id,
3964 client_end,
3965
3966 } = &mut *out_;
3967 }
3968
3969 ::fidl_next::Wire::zero_padding(id);
3970
3971 ::fidl_next::Wire::zero_padding(client_end);
3972
3973 unsafe {
3974 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3975 }
3976 }
3977 }
3978
3979 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
3980 where
3981 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3982 ___D: ::fidl_next::fuchsia::HandleDecoder,
3983 {
3984 fn decode(
3985 slot_: ::fidl_next::Slot<'_, Self>,
3986 decoder_: &mut ___D,
3987 _: (),
3988 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3989 if slot_.as_bytes()[12..16] != [0u8; 4] {
3990 return Err(::fidl_next::DecodeError::InvalidPadding);
3991 }
3992
3993 ::fidl_next::munge! {
3994 let Self {
3995
3996 mut id,
3997 mut client_end,
3998
3999 } = slot_;
4000 }
4001
4002 let _field = id.as_mut();
4003
4004 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4005
4006 let _field = client_end.as_mut();
4007
4008 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
4009
4010 Ok(())
4011 }
4012 }
4013
4014 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
4015 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
4016 }
4017
4018 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportRequest {}
4019
4020 #[derive(Debug)]
4022 #[repr(C)]
4023 pub struct CapabilityStoreDictionaryLegacyExportRequest {
4024 pub id: ::fidl_next::WireU64,
4025
4026 pub server_end: ::fidl_next::fuchsia::WireChannel,
4027 }
4028
4029 static_assertions::const_assert_eq!(
4030 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4031 16
4032 );
4033 static_assertions::const_assert_eq!(
4034 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4035 8
4036 );
4037
4038 static_assertions::const_assert_eq!(
4039 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
4040 0
4041 );
4042
4043 static_assertions::const_assert_eq!(
4044 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
4045 8
4046 );
4047
4048 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
4049 type Owned<'de> = CapabilityStoreDictionaryLegacyExportRequest;
4050
4051 #[inline]
4052 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4053 ::fidl_next::munge! {
4054 let Self {
4055
4056 id,
4057 server_end,
4058
4059 } = &mut *out_;
4060 }
4061
4062 ::fidl_next::Wire::zero_padding(id);
4063
4064 ::fidl_next::Wire::zero_padding(server_end);
4065
4066 unsafe {
4067 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4068 }
4069 }
4070 }
4071
4072 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
4073 where
4074 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4075 ___D: ::fidl_next::fuchsia::HandleDecoder,
4076 {
4077 fn decode(
4078 slot_: ::fidl_next::Slot<'_, Self>,
4079 decoder_: &mut ___D,
4080 _: (),
4081 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4082 if slot_.as_bytes()[12..16] != [0u8; 4] {
4083 return Err(::fidl_next::DecodeError::InvalidPadding);
4084 }
4085
4086 ::fidl_next::munge! {
4087 let Self {
4088
4089 mut id,
4090 mut server_end,
4091
4092 } = slot_;
4093 }
4094
4095 let _field = id.as_mut();
4096
4097 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4098
4099 let _field = server_end.as_mut();
4100
4101 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4102
4103 Ok(())
4104 }
4105 }
4106
4107 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
4108 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
4109 }
4110
4111 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportRequest {}
4112
4113 #[derive(Debug)]
4115 #[repr(C)]
4116 pub struct CapabilityStoreDictionaryKeysRequest {
4117 pub id: ::fidl_next::WireU64,
4118
4119 pub iterator: ::fidl_next::ServerEnd<
4120 crate::DictionaryKeysIterator,
4121 ::fidl_next::fuchsia::WireChannel,
4122 >,
4123 }
4124
4125 static_assertions::const_assert_eq!(
4126 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
4127 16
4128 );
4129 static_assertions::const_assert_eq!(
4130 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
4131 8
4132 );
4133
4134 static_assertions::const_assert_eq!(
4135 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
4136 0
4137 );
4138
4139 static_assertions::const_assert_eq!(
4140 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
4141 8
4142 );
4143
4144 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
4145 type Owned<'de> = CapabilityStoreDictionaryKeysRequest;
4146
4147 #[inline]
4148 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4149 ::fidl_next::munge! {
4150 let Self {
4151
4152 id,
4153 iterator,
4154
4155 } = &mut *out_;
4156 }
4157
4158 ::fidl_next::Wire::zero_padding(id);
4159
4160 ::fidl_next::Wire::zero_padding(iterator);
4161
4162 unsafe {
4163 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4164 }
4165 }
4166 }
4167
4168 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
4169 where
4170 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4171 ___D: ::fidl_next::fuchsia::HandleDecoder,
4172 {
4173 fn decode(
4174 slot_: ::fidl_next::Slot<'_, Self>,
4175 decoder_: &mut ___D,
4176 _: (),
4177 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4178 if slot_.as_bytes()[12..16] != [0u8; 4] {
4179 return Err(::fidl_next::DecodeError::InvalidPadding);
4180 }
4181
4182 ::fidl_next::munge! {
4183 let Self {
4184
4185 mut id,
4186 mut iterator,
4187
4188 } = slot_;
4189 }
4190
4191 let _field = id.as_mut();
4192
4193 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4194
4195 let _field = iterator.as_mut();
4196
4197 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4198
4199 Ok(())
4200 }
4201 }
4202
4203 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
4204 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
4205 }
4206
4207 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysRequest {}
4208
4209 #[derive(Debug)]
4211 #[repr(C)]
4212 pub struct CapabilityStoreDictionaryEnumerateRequest {
4213 pub id: ::fidl_next::WireU64,
4214
4215 pub iterator: ::fidl_next::ServerEnd<
4216 crate::DictionaryEnumerateIterator,
4217 ::fidl_next::fuchsia::WireChannel,
4218 >,
4219 }
4220
4221 static_assertions::const_assert_eq!(
4222 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4223 16
4224 );
4225 static_assertions::const_assert_eq!(
4226 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4227 8
4228 );
4229
4230 static_assertions::const_assert_eq!(
4231 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
4232 0
4233 );
4234
4235 static_assertions::const_assert_eq!(
4236 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
4237 8
4238 );
4239
4240 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
4241 type Owned<'de> = CapabilityStoreDictionaryEnumerateRequest;
4242
4243 #[inline]
4244 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4245 ::fidl_next::munge! {
4246 let Self {
4247
4248 id,
4249 iterator,
4250
4251 } = &mut *out_;
4252 }
4253
4254 ::fidl_next::Wire::zero_padding(id);
4255
4256 ::fidl_next::Wire::zero_padding(iterator);
4257
4258 unsafe {
4259 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4260 }
4261 }
4262 }
4263
4264 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
4265 where
4266 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4267 ___D: ::fidl_next::fuchsia::HandleDecoder,
4268 {
4269 fn decode(
4270 slot_: ::fidl_next::Slot<'_, Self>,
4271 decoder_: &mut ___D,
4272 _: (),
4273 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4274 if slot_.as_bytes()[12..16] != [0u8; 4] {
4275 return Err(::fidl_next::DecodeError::InvalidPadding);
4276 }
4277
4278 ::fidl_next::munge! {
4279 let Self {
4280
4281 mut id,
4282 mut iterator,
4283
4284 } = slot_;
4285 }
4286
4287 let _field = id.as_mut();
4288
4289 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4290
4291 let _field = iterator.as_mut();
4292
4293 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4294
4295 Ok(())
4296 }
4297 }
4298
4299 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
4300 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
4301 }
4302
4303 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateRequest {}
4304
4305 #[derive(Debug)]
4307 #[repr(C)]
4308 pub struct CapabilityStoreDictionaryDrainRequest {
4309 pub id: ::fidl_next::WireU64,
4310
4311 pub iterator: ::fidl_next::ServerEnd<
4312 crate::DictionaryDrainIterator,
4313 ::fidl_next::fuchsia::WireOptionalChannel,
4314 >,
4315 }
4316
4317 static_assertions::const_assert_eq!(
4318 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
4319 16
4320 );
4321 static_assertions::const_assert_eq!(
4322 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
4323 8
4324 );
4325
4326 static_assertions::const_assert_eq!(
4327 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
4328 0
4329 );
4330
4331 static_assertions::const_assert_eq!(
4332 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
4333 8
4334 );
4335
4336 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
4337 type Owned<'de> = CapabilityStoreDictionaryDrainRequest;
4338
4339 #[inline]
4340 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4341 ::fidl_next::munge! {
4342 let Self {
4343
4344 id,
4345 iterator,
4346
4347 } = &mut *out_;
4348 }
4349
4350 ::fidl_next::Wire::zero_padding(id);
4351
4352 ::fidl_next::Wire::zero_padding(iterator);
4353
4354 unsafe {
4355 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4356 }
4357 }
4358 }
4359
4360 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
4361 where
4362 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4363 ___D: ::fidl_next::fuchsia::HandleDecoder,
4364 {
4365 fn decode(
4366 slot_: ::fidl_next::Slot<'_, Self>,
4367 decoder_: &mut ___D,
4368 _: (),
4369 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4370 if slot_.as_bytes()[12..16] != [0u8; 4] {
4371 return Err(::fidl_next::DecodeError::InvalidPadding);
4372 }
4373
4374 ::fidl_next::munge! {
4375 let Self {
4376
4377 mut id,
4378 mut iterator,
4379
4380 } = slot_;
4381 }
4382
4383 let _field = id.as_mut();
4384
4385 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4386
4387 let _field = iterator.as_mut();
4388
4389 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4390
4391 Ok(())
4392 }
4393 }
4394
4395 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
4396 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
4397 }
4398
4399 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainRequest {}
4400
4401 #[derive(Debug)]
4403 #[repr(C)]
4404 pub struct CapabilityStoreExportResponse<'de> {
4405 pub capability: crate::wire::Capability<'de>,
4406 }
4407
4408 static_assertions::const_assert_eq!(
4409 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
4410 16
4411 );
4412 static_assertions::const_assert_eq!(
4413 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
4414 8
4415 );
4416
4417 static_assertions::const_assert_eq!(
4418 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
4419 0
4420 );
4421
4422 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
4423 type Owned<'de> = CapabilityStoreExportResponse<'de>;
4424
4425 #[inline]
4426 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4427 ::fidl_next::munge! {
4428 let Self {
4429
4430 capability,
4431
4432 } = &mut *out_;
4433 }
4434
4435 ::fidl_next::Wire::zero_padding(capability);
4436 }
4437 }
4438
4439 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'static>
4440 where
4441 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4442 ___D: ::fidl_next::Decoder,
4443 ___D: ::fidl_next::fuchsia::HandleDecoder,
4444 {
4445 fn decode(
4446 slot_: ::fidl_next::Slot<'_, Self>,
4447 decoder_: &mut ___D,
4448 _: (),
4449 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4450 ::fidl_next::munge! {
4451 let Self {
4452
4453 mut capability,
4454
4455 } = slot_;
4456 }
4457
4458 let _field = capability.as_mut();
4459
4460 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
4461
4462 Ok(())
4463 }
4464 }
4465
4466 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
4467 type Natural = crate::natural::CapabilityStoreExportResponse;
4468 }
4469
4470 impl ::fidl_next::Unconstrained for CapabilityStoreExportResponse<'static> {}
4471
4472 #[derive(Debug)]
4474 #[repr(C)]
4475 pub struct CapabilityStoreImportRequest<'de> {
4476 pub id: ::fidl_next::WireU64,
4477
4478 pub capability: crate::wire::Capability<'de>,
4479 }
4480
4481 static_assertions::const_assert_eq!(
4482 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
4483 24
4484 );
4485 static_assertions::const_assert_eq!(
4486 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
4487 8
4488 );
4489
4490 static_assertions::const_assert_eq!(
4491 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
4492 0
4493 );
4494
4495 static_assertions::const_assert_eq!(
4496 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
4497 8
4498 );
4499
4500 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
4501 type Owned<'de> = CapabilityStoreImportRequest<'de>;
4502
4503 #[inline]
4504 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4505 ::fidl_next::munge! {
4506 let Self {
4507
4508 id,
4509 capability,
4510
4511 } = &mut *out_;
4512 }
4513
4514 ::fidl_next::Wire::zero_padding(id);
4515
4516 ::fidl_next::Wire::zero_padding(capability);
4517 }
4518 }
4519
4520 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'static>
4521 where
4522 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4523 ___D: ::fidl_next::Decoder,
4524 ___D: ::fidl_next::fuchsia::HandleDecoder,
4525 {
4526 fn decode(
4527 slot_: ::fidl_next::Slot<'_, Self>,
4528 decoder_: &mut ___D,
4529 _: (),
4530 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4531 ::fidl_next::munge! {
4532 let Self {
4533
4534 mut id,
4535 mut capability,
4536
4537 } = slot_;
4538 }
4539
4540 let _field = id.as_mut();
4541
4542 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4543
4544 let _field = capability.as_mut();
4545
4546 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
4547
4548 Ok(())
4549 }
4550 }
4551
4552 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
4553 type Natural = crate::natural::CapabilityStoreImportRequest;
4554 }
4555
4556 impl ::fidl_next::Unconstrained for CapabilityStoreImportRequest<'static> {}
4557
4558 #[derive(Debug)]
4560 #[repr(C)]
4561 pub struct CapabilityStoreDirConnectorCreateRequest {
4562 pub id: ::fidl_next::WireU64,
4563
4564 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
4565 }
4566
4567 static_assertions::const_assert_eq!(
4568 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
4569 16
4570 );
4571 static_assertions::const_assert_eq!(
4572 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
4573 8
4574 );
4575
4576 static_assertions::const_assert_eq!(
4577 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
4578 0
4579 );
4580
4581 static_assertions::const_assert_eq!(
4582 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
4583 8
4584 );
4585
4586 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
4587 type Owned<'de> = CapabilityStoreDirConnectorCreateRequest;
4588
4589 #[inline]
4590 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4591 ::fidl_next::munge! {
4592 let Self {
4593
4594 id,
4595 receiver,
4596
4597 } = &mut *out_;
4598 }
4599
4600 ::fidl_next::Wire::zero_padding(id);
4601
4602 ::fidl_next::Wire::zero_padding(receiver);
4603
4604 unsafe {
4605 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4606 }
4607 }
4608 }
4609
4610 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
4611 where
4612 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4613 ___D: ::fidl_next::fuchsia::HandleDecoder,
4614 {
4615 fn decode(
4616 slot_: ::fidl_next::Slot<'_, Self>,
4617 decoder_: &mut ___D,
4618 _: (),
4619 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4620 if slot_.as_bytes()[12..16] != [0u8; 4] {
4621 return Err(::fidl_next::DecodeError::InvalidPadding);
4622 }
4623
4624 ::fidl_next::munge! {
4625 let Self {
4626
4627 mut id,
4628 mut receiver,
4629
4630 } = slot_;
4631 }
4632
4633 let _field = id.as_mut();
4634
4635 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4636
4637 let _field = receiver.as_mut();
4638
4639 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4640
4641 Ok(())
4642 }
4643 }
4644
4645 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
4646 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
4647 }
4648
4649 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateRequest {}
4650
4651 #[derive(Debug)]
4653 #[repr(C)]
4654 pub struct CapabilityStoreDirConnectorOpenRequest {
4655 pub id: ::fidl_next::WireU64,
4656
4657 pub server_end: ::fidl_next::ServerEnd<
4658 ::fidl_next_fuchsia_io::Directory,
4659 ::fidl_next::fuchsia::WireChannel,
4660 >,
4661 }
4662
4663 static_assertions::const_assert_eq!(
4664 std::mem::size_of::<CapabilityStoreDirConnectorOpenRequest>(),
4665 16
4666 );
4667 static_assertions::const_assert_eq!(
4668 std::mem::align_of::<CapabilityStoreDirConnectorOpenRequest>(),
4669 8
4670 );
4671
4672 static_assertions::const_assert_eq!(
4673 std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, id),
4674 0
4675 );
4676
4677 static_assertions::const_assert_eq!(
4678 std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, server_end),
4679 8
4680 );
4681
4682 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest {
4683 type Owned<'de> = CapabilityStoreDirConnectorOpenRequest;
4684
4685 #[inline]
4686 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4687 ::fidl_next::munge! {
4688 let Self {
4689
4690 id,
4691 server_end,
4692
4693 } = &mut *out_;
4694 }
4695
4696 ::fidl_next::Wire::zero_padding(id);
4697
4698 ::fidl_next::Wire::zero_padding(server_end);
4699
4700 unsafe {
4701 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4702 }
4703 }
4704 }
4705
4706 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest
4707 where
4708 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4709 ___D: ::fidl_next::fuchsia::HandleDecoder,
4710 {
4711 fn decode(
4712 slot_: ::fidl_next::Slot<'_, Self>,
4713 decoder_: &mut ___D,
4714 _: (),
4715 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4716 if slot_.as_bytes()[12..16] != [0u8; 4] {
4717 return Err(::fidl_next::DecodeError::InvalidPadding);
4718 }
4719
4720 ::fidl_next::munge! {
4721 let Self {
4722
4723 mut id,
4724 mut server_end,
4725
4726 } = slot_;
4727 }
4728
4729 let _field = id.as_mut();
4730
4731 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4732
4733 let _field = server_end.as_mut();
4734
4735 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4736
4737 Ok(())
4738 }
4739 }
4740
4741 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest {
4742 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
4743 }
4744
4745 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenRequest {}
4746
4747 #[derive(Debug)]
4749 #[repr(C)]
4750 pub struct InstanceToken {
4751 pub token: ::fidl_next::fuchsia::WireEventPair,
4752 }
4753
4754 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
4755 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
4756
4757 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
4758
4759 unsafe impl ::fidl_next::Wire for InstanceToken {
4760 type Owned<'de> = InstanceToken;
4761
4762 #[inline]
4763 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4764 ::fidl_next::munge! {
4765 let Self {
4766
4767 token,
4768
4769 } = &mut *out_;
4770 }
4771
4772 ::fidl_next::Wire::zero_padding(token);
4773 }
4774 }
4775
4776 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
4777 where
4778 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4779 ___D: ::fidl_next::fuchsia::HandleDecoder,
4780 {
4781 fn decode(
4782 slot_: ::fidl_next::Slot<'_, Self>,
4783 decoder_: &mut ___D,
4784 _: (),
4785 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4786 ::fidl_next::munge! {
4787 let Self {
4788
4789 mut token,
4790
4791 } = slot_;
4792 }
4793
4794 let _field = token.as_mut();
4795
4796 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
4797
4798 Ok(())
4799 }
4800 }
4801
4802 impl ::fidl_next::IntoNatural for InstanceToken {
4803 type Natural = crate::natural::InstanceToken;
4804 }
4805
4806 impl ::fidl_next::Unconstrained for InstanceToken {}
4807
4808 #[repr(C)]
4810 pub struct RouteRequest<'de> {
4811 pub(crate) table: ::fidl_next::WireTable<'de>,
4812 }
4813
4814 impl<'de> Drop for RouteRequest<'de> {
4815 fn drop(&mut self) {
4816 let _ = self
4817 .table
4818 .get(1)
4819 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
4820
4821 let _ = self
4822 .table
4823 .get(2)
4824 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
4825 }
4826 }
4827
4828 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
4829 type Owned<'de> = RouteRequest<'de>;
4830
4831 #[inline]
4832 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4833 ::fidl_next::munge!(let Self { table } = out);
4834 ::fidl_next::WireTable::zero_padding(table);
4835 }
4836 }
4837
4838 unsafe impl<___D> ::fidl_next::Decode<___D> for RouteRequest<'static>
4839 where
4840 ___D: ::fidl_next::Decoder + ?Sized,
4841 ___D: ::fidl_next::fuchsia::HandleDecoder,
4842 {
4843 fn decode(
4844 slot: ::fidl_next::Slot<'_, Self>,
4845 decoder: &mut ___D,
4846 _: (),
4847 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4848 ::fidl_next::munge!(let Self { table } = slot);
4849
4850 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4851 match ordinal {
4852 0 => unsafe { ::core::hint::unreachable_unchecked() },
4853
4854 1 => {
4855 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::InstanceToken>(
4856 slot.as_mut(),
4857 decoder,
4858 (),
4859 )?;
4860
4861 Ok(())
4862 }
4863
4864 2 => {
4865 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DictionaryRef>(
4866 slot.as_mut(),
4867 decoder,
4868 (),
4869 )?;
4870
4871 Ok(())
4872 }
4873
4874 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
4875 }
4876 })
4877 }
4878 }
4879
4880 impl<'de> RouteRequest<'de> {
4881 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
4882 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4883 }
4884
4885 pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
4886 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4887 }
4888 }
4889
4890 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
4891 fn fmt(
4892 &self,
4893 f: &mut ::core::fmt::Formatter<'_>,
4894 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4895 f.debug_struct("RouteRequest")
4896 .field("requesting", &self.requesting())
4897 .field("metadata", &self.metadata())
4898 .finish()
4899 }
4900 }
4901
4902 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
4903 type Natural = crate::natural::RouteRequest;
4904 }
4905
4906 impl ::fidl_next::Unconstrained for RouteRequest<'_> {}
4907
4908 #[repr(transparent)]
4910 pub struct ConnectorRouterRouteResponse {
4911 pub(crate) raw: ::fidl_next::RawWireUnion,
4912 pub(crate) _phantom: ::core::marker::PhantomData<()>,
4913 }
4914
4915 impl Drop for ConnectorRouterRouteResponse {
4916 fn drop(&mut self) {
4917 match self.raw.ordinal() {
4918 1 => {
4919 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
4920 }
4921
4922 2 => {
4923 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
4924 }
4925
4926 _ => unsafe { ::core::hint::unreachable_unchecked() },
4927 }
4928 }
4929 }
4930
4931 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
4932 type Owned<'de> = ConnectorRouterRouteResponse;
4933
4934 #[inline]
4935 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4936 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4937 ::fidl_next::RawWireUnion::zero_padding(raw);
4938 }
4939 }
4940
4941 pub mod connector_router_route_response {
4942 pub enum Ref<'de> {
4943 Connector(&'de crate::wire::Connector),
4944
4945 Unavailable(&'de crate::wire::Unit),
4946 }
4947 }
4948
4949 impl ConnectorRouterRouteResponse {
4950 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
4951 match self.raw.ordinal() {
4952 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
4953 self.raw.get().deref_unchecked::<crate::wire::Connector>()
4954 }),
4955
4956 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
4957 self.raw.get().deref_unchecked::<crate::wire::Unit>()
4958 }),
4959
4960 _ => unsafe { ::core::hint::unreachable_unchecked() },
4961 }
4962 }
4963 }
4964
4965 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
4966 where
4967 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4968 ___D: ::fidl_next::fuchsia::HandleDecoder,
4969 {
4970 fn decode(
4971 mut slot: ::fidl_next::Slot<'_, Self>,
4972 decoder: &mut ___D,
4973 _: (),
4974 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4975 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4976 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4977 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
4978 raw,
4979 decoder,
4980 (),
4981 )?,
4982
4983 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
4984 raw,
4985 decoder,
4986 (),
4987 )?,
4988
4989 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4990 }
4991
4992 Ok(())
4993 }
4994 }
4995
4996 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
4997 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4998 match self.raw.ordinal() {
4999 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
5000 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5001 _ => unsafe { ::core::hint::unreachable_unchecked() },
5002 }
5003 }
5004 }
5005
5006 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
5007 type Natural = crate::natural::ConnectorRouterRouteResponse;
5008 }
5009
5010 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
5011
5012 #[repr(transparent)]
5014 pub struct DataRouterRouteResponse<'de> {
5015 pub(crate) raw: ::fidl_next::RawWireUnion,
5016 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
5017 }
5018
5019 impl<'de> Drop for DataRouterRouteResponse<'de> {
5020 fn drop(&mut self) {
5021 match self.raw.ordinal() {
5022 1 => {
5023 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
5024 }
5025
5026 2 => {
5027 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5028 }
5029
5030 _ => unsafe { ::core::hint::unreachable_unchecked() },
5031 }
5032 }
5033 }
5034
5035 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
5036 type Owned<'de> = DataRouterRouteResponse<'de>;
5037
5038 #[inline]
5039 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5040 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5041 ::fidl_next::RawWireUnion::zero_padding(raw);
5042 }
5043 }
5044
5045 pub mod data_router_route_response {
5046 pub enum Ref<'de> {
5047 Data(&'de crate::wire::Data<'de>),
5048
5049 Unavailable(&'de crate::wire::Unit),
5050 }
5051 }
5052
5053 impl<'de> DataRouterRouteResponse<'de> {
5054 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
5055 match self.raw.ordinal() {
5056 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
5057 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
5058 }),
5059
5060 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
5061 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5062 }),
5063
5064 _ => unsafe { ::core::hint::unreachable_unchecked() },
5065 }
5066 }
5067 }
5068
5069 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
5070 where
5071 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5072 ___D: ::fidl_next::Decoder,
5073 ___D: ::fidl_next::fuchsia::HandleDecoder,
5074 {
5075 fn decode(
5076 mut slot: ::fidl_next::Slot<'_, Self>,
5077 decoder: &mut ___D,
5078 _: (),
5079 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5080 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5081 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5082 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
5083 raw,
5084 decoder,
5085 (),
5086 )?,
5087
5088 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
5089 raw,
5090 decoder,
5091 (),
5092 )?,
5093
5094 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5095 }
5096
5097 Ok(())
5098 }
5099 }
5100
5101 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
5102 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5103 match self.raw.ordinal() {
5104 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
5105 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5106 _ => unsafe { ::core::hint::unreachable_unchecked() },
5107 }
5108 }
5109 }
5110
5111 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
5112 type Natural = crate::natural::DataRouterRouteResponse;
5113 }
5114
5115 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
5116
5117 #[derive(Debug)]
5119 #[repr(C)]
5120 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
5121 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryItem<'de>>,
5122
5123 pub end_id: ::fidl_next::WireU64,
5124 }
5125
5126 static_assertions::const_assert_eq!(
5127 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5128 24
5129 );
5130 static_assertions::const_assert_eq!(
5131 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5132 8
5133 );
5134
5135 static_assertions::const_assert_eq!(
5136 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
5137 0
5138 );
5139
5140 static_assertions::const_assert_eq!(
5141 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
5142 16
5143 );
5144
5145 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
5146 type Owned<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
5147
5148 #[inline]
5149 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5150 ::fidl_next::munge! {
5151 let Self {
5152
5153 items,
5154 end_id,
5155
5156 } = &mut *out_;
5157 }
5158
5159 ::fidl_next::Wire::zero_padding(items);
5160
5161 ::fidl_next::Wire::zero_padding(end_id);
5162 }
5163 }
5164
5165 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'static>
5166 where
5167 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5168 ___D: ::fidl_next::Decoder,
5169 ___D: ::fidl_next::fuchsia::HandleDecoder,
5170 {
5171 fn decode(
5172 slot_: ::fidl_next::Slot<'_, Self>,
5173 decoder_: &mut ___D,
5174 _: (),
5175 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5176 ::fidl_next::munge! {
5177 let Self {
5178
5179 mut items,
5180 mut end_id,
5181
5182 } = slot_;
5183 }
5184
5185 let _field = items.as_mut();
5186 ::fidl_next::Constrained::validate(_field, (128, ()))?;
5187 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
5188
5189 let items = unsafe { items.deref_unchecked() };
5190
5191 if items.len() > 128 {
5192 return Err(::fidl_next::DecodeError::VectorTooLong {
5193 size: items.len() as u64,
5194 limit: 128,
5195 });
5196 }
5197
5198 let _field = end_id.as_mut();
5199
5200 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
5201
5202 Ok(())
5203 }
5204 }
5205
5206 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
5207 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
5208 }
5209
5210 impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextResponse<'static> {}
5211
5212 #[derive(Debug)]
5214 #[repr(C)]
5215 pub struct DictionaryOptionalItem<'de> {
5216 pub key: ::fidl_next::WireString<'de>,
5217
5218 pub value: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
5219 }
5220
5221 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
5222 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
5223
5224 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
5225
5226 static_assertions::const_assert_eq!(
5227 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
5228 16
5229 );
5230
5231 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
5232 type Owned<'de> = DictionaryOptionalItem<'de>;
5233
5234 #[inline]
5235 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5236 ::fidl_next::munge! {
5237 let Self {
5238
5239 key,
5240 value,
5241
5242 } = &mut *out_;
5243 }
5244
5245 ::fidl_next::Wire::zero_padding(key);
5246
5247 ::fidl_next::Wire::zero_padding(value);
5248 }
5249 }
5250
5251 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'static>
5252 where
5253 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5254 ___D: ::fidl_next::Decoder,
5255 ___D: ::fidl_next::fuchsia::HandleDecoder,
5256 {
5257 fn decode(
5258 slot_: ::fidl_next::Slot<'_, Self>,
5259 decoder_: &mut ___D,
5260 _: (),
5261 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5262 ::fidl_next::munge! {
5263 let Self {
5264
5265 mut key,
5266 mut value,
5267
5268 } = slot_;
5269 }
5270
5271 let _field = key.as_mut();
5272 ::fidl_next::Constrained::validate(_field, 255)?;
5273 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
5274
5275 let key = unsafe { key.deref_unchecked() };
5276
5277 if key.len() > 255 {
5278 return Err(::fidl_next::DecodeError::VectorTooLong {
5279 size: key.len() as u64,
5280 limit: 255,
5281 });
5282 }
5283
5284 let _field = value.as_mut();
5285
5286 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
5287
5288 Ok(())
5289 }
5290 }
5291
5292 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
5293 type Natural = crate::natural::DictionaryOptionalItem;
5294 }
5295
5296 impl ::fidl_next::Unconstrained for DictionaryOptionalItem<'static> {}
5297
5298 #[derive(Debug)]
5300 #[repr(C)]
5301 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
5302 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryOptionalItem<'de>>,
5303
5304 pub end_id: ::fidl_next::WireU64,
5305 }
5306
5307 static_assertions::const_assert_eq!(
5308 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
5309 24
5310 );
5311 static_assertions::const_assert_eq!(
5312 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
5313 8
5314 );
5315
5316 static_assertions::const_assert_eq!(
5317 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
5318 0
5319 );
5320
5321 static_assertions::const_assert_eq!(
5322 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
5323 16
5324 );
5325
5326 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
5327 type Owned<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
5328
5329 #[inline]
5330 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5331 ::fidl_next::munge! {
5332 let Self {
5333
5334 items,
5335 end_id,
5336
5337 } = &mut *out_;
5338 }
5339
5340 ::fidl_next::Wire::zero_padding(items);
5341
5342 ::fidl_next::Wire::zero_padding(end_id);
5343 }
5344 }
5345
5346 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'static>
5347 where
5348 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5349 ___D: ::fidl_next::Decoder,
5350 ___D: ::fidl_next::fuchsia::HandleDecoder,
5351 {
5352 fn decode(
5353 slot_: ::fidl_next::Slot<'_, Self>,
5354 decoder_: &mut ___D,
5355 _: (),
5356 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5357 ::fidl_next::munge! {
5358 let Self {
5359
5360 mut items,
5361 mut end_id,
5362
5363 } = slot_;
5364 }
5365
5366 let _field = items.as_mut();
5367 ::fidl_next::Constrained::validate(_field, (128, ()))?;
5368 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
5369
5370 let items = unsafe { items.deref_unchecked() };
5371
5372 if items.len() > 128 {
5373 return Err(::fidl_next::DecodeError::VectorTooLong {
5374 size: items.len() as u64,
5375 limit: 128,
5376 });
5377 }
5378
5379 let _field = end_id.as_mut();
5380
5381 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
5382
5383 Ok(())
5384 }
5385 }
5386
5387 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
5388 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
5389 }
5390
5391 impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextResponse<'static> {}
5392
5393 #[derive(Debug)]
5395 #[repr(C)]
5396 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
5397 pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
5398 }
5399
5400 static_assertions::const_assert_eq!(
5401 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
5402 16
5403 );
5404 static_assertions::const_assert_eq!(
5405 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
5406 8
5407 );
5408
5409 static_assertions::const_assert_eq!(
5410 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
5411 0
5412 );
5413
5414 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
5415 type Owned<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
5416
5417 #[inline]
5418 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5419 ::fidl_next::munge! {
5420 let Self {
5421
5422 keys,
5423
5424 } = &mut *out_;
5425 }
5426
5427 ::fidl_next::Wire::zero_padding(keys);
5428 }
5429 }
5430
5431 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'static>
5432 where
5433 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5434 ___D: ::fidl_next::Decoder,
5435 ___D: ::fidl_next::fuchsia::HandleDecoder,
5436 {
5437 fn decode(
5438 slot_: ::fidl_next::Slot<'_, Self>,
5439 decoder_: &mut ___D,
5440 _: (),
5441 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5442 ::fidl_next::munge! {
5443 let Self {
5444
5445 mut keys,
5446
5447 } = slot_;
5448 }
5449
5450 let _field = keys.as_mut();
5451 ::fidl_next::Constrained::validate(_field, (128, 255))?;
5452 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
5453
5454 let keys = unsafe { keys.deref_unchecked() };
5455
5456 if keys.len() > 128 {
5457 return Err(::fidl_next::DecodeError::VectorTooLong {
5458 size: keys.len() as u64,
5459 limit: 128,
5460 });
5461 }
5462
5463 Ok(())
5464 }
5465 }
5466
5467 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
5468 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
5469 }
5470
5471 impl ::fidl_next::Unconstrained for DictionaryKeysIteratorGetNextResponse<'static> {}
5472
5473 #[repr(transparent)]
5475 pub struct DictionaryRouterRouteResponse {
5476 pub(crate) raw: ::fidl_next::RawWireUnion,
5477 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5478 }
5479
5480 impl Drop for DictionaryRouterRouteResponse {
5481 fn drop(&mut self) {
5482 match self.raw.ordinal() {
5483 1 => {
5484 let _ =
5485 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
5486 }
5487
5488 2 => {
5489 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5490 }
5491
5492 _ => unsafe { ::core::hint::unreachable_unchecked() },
5493 }
5494 }
5495 }
5496
5497 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
5498 type Owned<'de> = DictionaryRouterRouteResponse;
5499
5500 #[inline]
5501 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5502 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5503 ::fidl_next::RawWireUnion::zero_padding(raw);
5504 }
5505 }
5506
5507 pub mod dictionary_router_route_response {
5508 pub enum Ref<'de> {
5509 Dictionary(&'de crate::wire::DictionaryRef),
5510
5511 Unavailable(&'de crate::wire::Unit),
5512 }
5513 }
5514
5515 impl DictionaryRouterRouteResponse {
5516 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
5517 match self.raw.ordinal() {
5518 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
5519 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
5520 }),
5521
5522 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
5523 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5524 }),
5525
5526 _ => unsafe { ::core::hint::unreachable_unchecked() },
5527 }
5528 }
5529 }
5530
5531 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
5532 where
5533 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5534 ___D: ::fidl_next::fuchsia::HandleDecoder,
5535 {
5536 fn decode(
5537 mut slot: ::fidl_next::Slot<'_, Self>,
5538 decoder: &mut ___D,
5539 _: (),
5540 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5541 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5542 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5543 1 => {
5544 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
5545 raw,
5546 decoder,
5547 (),
5548 )?
5549 }
5550
5551 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5552 raw,
5553 decoder,
5554 (),
5555 )?,
5556
5557 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5558 }
5559
5560 Ok(())
5561 }
5562 }
5563
5564 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
5565 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5566 match self.raw.ordinal() {
5567 1 => unsafe {
5568 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
5569 },
5570 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5571 _ => unsafe { ::core::hint::unreachable_unchecked() },
5572 }
5573 }
5574 }
5575
5576 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
5577 type Natural = crate::natural::DictionaryRouterRouteResponse;
5578 }
5579
5580 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
5581
5582 #[repr(transparent)]
5584 pub struct DirConnectorRouterRouteResponse {
5585 pub(crate) raw: ::fidl_next::RawWireUnion,
5586 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5587 }
5588
5589 impl Drop for DirConnectorRouterRouteResponse {
5590 fn drop(&mut self) {
5591 match self.raw.ordinal() {
5592 1 => {
5593 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
5594 }
5595
5596 2 => {
5597 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5598 }
5599
5600 _ => unsafe { ::core::hint::unreachable_unchecked() },
5601 }
5602 }
5603 }
5604
5605 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
5606 type Owned<'de> = DirConnectorRouterRouteResponse;
5607
5608 #[inline]
5609 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5610 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5611 ::fidl_next::RawWireUnion::zero_padding(raw);
5612 }
5613 }
5614
5615 pub mod dir_connector_router_route_response {
5616 pub enum Ref<'de> {
5617 DirConnector(&'de crate::wire::DirConnector),
5618
5619 Unavailable(&'de crate::wire::Unit),
5620 }
5621 }
5622
5623 impl DirConnectorRouterRouteResponse {
5624 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
5625 match self.raw.ordinal() {
5626 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
5627 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
5628 }),
5629
5630 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
5631 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5632 }),
5633
5634 _ => unsafe { ::core::hint::unreachable_unchecked() },
5635 }
5636 }
5637 }
5638
5639 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
5640 where
5641 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5642 ___D: ::fidl_next::fuchsia::HandleDecoder,
5643 {
5644 fn decode(
5645 mut slot: ::fidl_next::Slot<'_, Self>,
5646 decoder: &mut ___D,
5647 _: (),
5648 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5649 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5650 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5651 1 => {
5652 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
5653 raw,
5654 decoder,
5655 (),
5656 )?
5657 }
5658
5659 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5660 raw,
5661 decoder,
5662 (),
5663 )?,
5664
5665 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5666 }
5667
5668 Ok(())
5669 }
5670 }
5671
5672 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
5673 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5674 match self.raw.ordinal() {
5675 1 => unsafe {
5676 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
5677 },
5678 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5679 _ => unsafe { ::core::hint::unreachable_unchecked() },
5680 }
5681 }
5682 }
5683
5684 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
5685 type Natural = crate::natural::DirConnectorRouterRouteResponse;
5686 }
5687
5688 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
5689
5690 #[repr(transparent)]
5692 pub struct DirEntryRouterRouteResponse {
5693 pub(crate) raw: ::fidl_next::RawWireUnion,
5694 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5695 }
5696
5697 impl Drop for DirEntryRouterRouteResponse {
5698 fn drop(&mut self) {
5699 match self.raw.ordinal() {
5700 1 => {
5701 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
5702 }
5703
5704 2 => {
5705 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5706 }
5707
5708 _ => unsafe { ::core::hint::unreachable_unchecked() },
5709 }
5710 }
5711 }
5712
5713 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
5714 type Owned<'de> = DirEntryRouterRouteResponse;
5715
5716 #[inline]
5717 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5718 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5719 ::fidl_next::RawWireUnion::zero_padding(raw);
5720 }
5721 }
5722
5723 pub mod dir_entry_router_route_response {
5724 pub enum Ref<'de> {
5725 DirEntry(&'de crate::wire::DirEntry),
5726
5727 Unavailable(&'de crate::wire::Unit),
5728 }
5729 }
5730
5731 impl DirEntryRouterRouteResponse {
5732 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
5733 match self.raw.ordinal() {
5734 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
5735 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
5736 }),
5737
5738 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
5739 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5740 }),
5741
5742 _ => unsafe { ::core::hint::unreachable_unchecked() },
5743 }
5744 }
5745 }
5746
5747 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
5748 where
5749 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5750 ___D: ::fidl_next::fuchsia::HandleDecoder,
5751 {
5752 fn decode(
5753 mut slot: ::fidl_next::Slot<'_, Self>,
5754 decoder: &mut ___D,
5755 _: (),
5756 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5757 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5758 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5759 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
5760 raw,
5761 decoder,
5762 (),
5763 )?,
5764
5765 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5766 raw,
5767 decoder,
5768 (),
5769 )?,
5770
5771 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5772 }
5773
5774 Ok(())
5775 }
5776 }
5777
5778 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
5779 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5780 match self.raw.ordinal() {
5781 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
5782 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5783 _ => unsafe { ::core::hint::unreachable_unchecked() },
5784 }
5785 }
5786 }
5787
5788 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
5789 type Natural = crate::natural::DirEntryRouterRouteResponse;
5790 }
5791
5792 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
5793
5794 #[derive(Debug)]
5796 #[repr(C)]
5797 pub struct DirReceiverReceiveRequest {
5798 pub channel: ::fidl_next::ServerEnd<
5799 ::fidl_next_fuchsia_io::Directory,
5800 ::fidl_next::fuchsia::WireChannel,
5801 >,
5802 }
5803
5804 static_assertions::const_assert_eq!(std::mem::size_of::<DirReceiverReceiveRequest>(), 4);
5805 static_assertions::const_assert_eq!(std::mem::align_of::<DirReceiverReceiveRequest>(), 4);
5806
5807 static_assertions::const_assert_eq!(
5808 std::mem::offset_of!(DirReceiverReceiveRequest, channel),
5809 0
5810 );
5811
5812 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest {
5813 type Owned<'de> = DirReceiverReceiveRequest;
5814
5815 #[inline]
5816 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5817 ::fidl_next::munge! {
5818 let Self {
5819
5820 channel,
5821
5822 } = &mut *out_;
5823 }
5824
5825 ::fidl_next::Wire::zero_padding(channel);
5826 }
5827 }
5828
5829 unsafe impl<___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest
5830 where
5831 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5832 ___D: ::fidl_next::fuchsia::HandleDecoder,
5833 {
5834 fn decode(
5835 slot_: ::fidl_next::Slot<'_, Self>,
5836 decoder_: &mut ___D,
5837 _: (),
5838 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5839 ::fidl_next::munge! {
5840 let Self {
5841
5842 mut channel,
5843
5844 } = slot_;
5845 }
5846
5847 let _field = channel.as_mut();
5848
5849 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
5850
5851 Ok(())
5852 }
5853 }
5854
5855 impl ::fidl_next::IntoNatural for DirReceiverReceiveRequest {
5856 type Natural = crate::natural::DirReceiverReceiveRequest;
5857 }
5858
5859 impl ::fidl_next::Unconstrained for DirReceiverReceiveRequest {}
5860
5861 #[repr(transparent)]
5863 pub struct DirectoryRouterRouteResponse {
5864 pub(crate) raw: ::fidl_next::RawWireUnion,
5865 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5866 }
5867
5868 impl Drop for DirectoryRouterRouteResponse {
5869 fn drop(&mut self) {
5870 match self.raw.ordinal() {
5871 1 => {
5872 let _ = unsafe {
5873 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
5874 ::fidl_next_fuchsia_io::Directory,
5875 ::fidl_next::fuchsia::WireChannel,
5876 >>()
5877 };
5878 }
5879
5880 2 => {
5881 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5882 }
5883
5884 _ => unsafe { ::core::hint::unreachable_unchecked() },
5885 }
5886 }
5887 }
5888
5889 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
5890 type Owned<'de> = DirectoryRouterRouteResponse;
5891
5892 #[inline]
5893 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5894 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5895 ::fidl_next::RawWireUnion::zero_padding(raw);
5896 }
5897 }
5898
5899 pub mod directory_router_route_response {
5900 pub enum Ref<'de> {
5901 Directory(
5902 &'de ::fidl_next::ClientEnd<
5903 ::fidl_next_fuchsia_io::Directory,
5904 ::fidl_next::fuchsia::WireChannel,
5905 >,
5906 ),
5907
5908 Unavailable(&'de crate::wire::Unit),
5909 }
5910 }
5911
5912 impl DirectoryRouterRouteResponse {
5913 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
5914 match self.raw.ordinal() {
5915 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
5916 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
5917 ::fidl_next_fuchsia_io::Directory,
5918 ::fidl_next::fuchsia::WireChannel,
5919 >>()
5920 }),
5921
5922 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
5923 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5924 }),
5925
5926 _ => unsafe { ::core::hint::unreachable_unchecked() },
5927 }
5928 }
5929 }
5930
5931 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
5932 where
5933 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5934 ___D: ::fidl_next::fuchsia::HandleDecoder,
5935 {
5936 fn decode(
5937 mut slot: ::fidl_next::Slot<'_, Self>,
5938 decoder: &mut ___D,
5939 _: (),
5940 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5941 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5942 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5943 1 => ::fidl_next::RawWireUnion::decode_as_static::<
5944 ___D,
5945 ::fidl_next::ClientEnd<
5946 ::fidl_next_fuchsia_io::Directory,
5947 ::fidl_next::fuchsia::WireChannel,
5948 >,
5949 >(raw, decoder, ())?,
5950
5951 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5952 raw,
5953 decoder,
5954 (),
5955 )?,
5956
5957 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5958 }
5959
5960 Ok(())
5961 }
5962 }
5963
5964 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
5965 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5966 match self.raw.ordinal() {
5967 1 => unsafe {
5968 self.raw
5969 .get()
5970 .deref_unchecked::<::fidl_next::ClientEnd<
5971 ::fidl_next_fuchsia_io::Directory,
5972 ::fidl_next::fuchsia::WireChannel,
5973 >>()
5974 .fmt(f)
5975 },
5976 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5977 _ => unsafe { ::core::hint::unreachable_unchecked() },
5978 }
5979 }
5980 }
5981
5982 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
5983 type Natural = crate::natural::DirectoryRouterRouteResponse;
5984 }
5985
5986 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
5987
5988 #[derive(Debug)]
5990 #[repr(C)]
5991 pub struct ProtocolPayload {
5992 pub channel: ::fidl_next::fuchsia::WireChannel,
5993 }
5994
5995 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
5996 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
5997
5998 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
5999
6000 unsafe impl ::fidl_next::Wire for ProtocolPayload {
6001 type Owned<'de> = ProtocolPayload;
6002
6003 #[inline]
6004 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6005 ::fidl_next::munge! {
6006 let Self {
6007
6008 channel,
6009
6010 } = &mut *out_;
6011 }
6012
6013 ::fidl_next::Wire::zero_padding(channel);
6014 }
6015 }
6016
6017 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
6018 where
6019 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6020 ___D: ::fidl_next::fuchsia::HandleDecoder,
6021 {
6022 fn decode(
6023 slot_: ::fidl_next::Slot<'_, Self>,
6024 decoder_: &mut ___D,
6025 _: (),
6026 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6027 ::fidl_next::munge! {
6028 let Self {
6029
6030 mut channel,
6031
6032 } = slot_;
6033 }
6034
6035 let _field = channel.as_mut();
6036
6037 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
6038
6039 Ok(())
6040 }
6041 }
6042
6043 impl ::fidl_next::IntoNatural for ProtocolPayload {
6044 type Natural = crate::natural::ProtocolPayload;
6045 }
6046
6047 impl ::fidl_next::Unconstrained for ProtocolPayload {}
6048}
6049
6050pub mod wire_optional {
6051
6052 pub use fidl_next_common_fuchsia_component_sandbox::wire_optional::*;
6053
6054 #[repr(transparent)]
6055 pub struct Capability<'de> {
6056 pub(crate) raw: ::fidl_next::RawWireUnion,
6057 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6058 }
6059
6060 unsafe impl ::fidl_next::Wire for Capability<'static> {
6061 type Owned<'de> = Capability<'de>;
6062
6063 #[inline]
6064 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6065 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6066 ::fidl_next::RawWireUnion::zero_padding(raw);
6067 }
6068 }
6069
6070 impl<'de> Capability<'de> {
6071 pub fn is_some(&self) -> bool {
6072 self.raw.is_some()
6073 }
6074
6075 pub fn is_none(&self) -> bool {
6076 self.raw.is_none()
6077 }
6078
6079 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
6080 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6081 }
6082
6083 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
6084 if self.is_some() {
6085 Some(crate::wire::Capability {
6086 raw: self.raw,
6087 _phantom: ::core::marker::PhantomData,
6088 })
6089 } else {
6090 None
6091 }
6092 }
6093 }
6094
6095 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
6096 where
6097 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6098 ___D: ::fidl_next::Decoder,
6099 ___D: ::fidl_next::fuchsia::HandleDecoder,
6100 {
6101 fn decode(
6102 mut slot: ::fidl_next::Slot<'_, Self>,
6103 decoder: &mut ___D,
6104 _: (),
6105 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6106 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6107 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6108 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
6109 raw,
6110 decoder,
6111 (),
6112 )?,
6113
6114 2 => {
6115 ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
6116 raw,
6117 decoder,
6118 (),
6119 )?
6120 }
6121
6122 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
6123 raw,
6124 decoder,
6125 (),
6126 )?,
6127
6128 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
6129 raw,
6130 decoder,
6131 (),
6132 )?,
6133
6134 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
6135 raw,
6136 decoder,
6137 (),
6138 )?,
6139
6140 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
6141 raw,
6142 decoder,
6143 (),
6144 )?,
6145
6146 7 => ::fidl_next::RawWireUnion::decode_as::<
6147 ___D,
6148 ::fidl_next::ClientEnd<
6149 ::fidl_next_fuchsia_io::Directory,
6150 ::fidl_next::fuchsia::WireChannel,
6151 >,
6152 >(raw, decoder, ())?,
6153
6154 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
6155 raw,
6156 decoder,
6157 (),
6158 )?,
6159
6160 9 => ::fidl_next::RawWireUnion::decode_as::<
6161 ___D,
6162 ::fidl_next::ClientEnd<
6163 crate::ConnectorRouter,
6164 ::fidl_next::fuchsia::WireChannel,
6165 >,
6166 >(raw, decoder, ())?,
6167
6168 10 => ::fidl_next::RawWireUnion::decode_as::<
6169 ___D,
6170 ::fidl_next::ClientEnd<
6171 crate::DictionaryRouter,
6172 ::fidl_next::fuchsia::WireChannel,
6173 >,
6174 >(raw, decoder, ())?,
6175
6176 11 => ::fidl_next::RawWireUnion::decode_as::<
6177 ___D,
6178 ::fidl_next::ClientEnd<
6179 crate::DirEntryRouter,
6180 ::fidl_next::fuchsia::WireChannel,
6181 >,
6182 >(raw, decoder, ())?,
6183
6184 12 => ::fidl_next::RawWireUnion::decode_as::<
6185 ___D,
6186 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
6187 >(raw, decoder, ())?,
6188
6189 13 => ::fidl_next::RawWireUnion::decode_as::<
6190 ___D,
6191 ::fidl_next::ClientEnd<
6192 crate::DirConnectorRouter,
6193 ::fidl_next::fuchsia::WireChannel,
6194 >,
6195 >(raw, decoder, ())?,
6196
6197 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6198 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
6199 }
6200
6201 Ok(())
6202 }
6203 }
6204
6205 impl<'de> ::core::fmt::Debug for Capability<'de> {
6206 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6207 self.as_ref().fmt(f)
6208 }
6209 }
6210
6211 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
6212 type Natural = ::core::option::Option<crate::natural::Capability>;
6213 }
6214
6215 impl ::fidl_next::Unconstrained for Capability<'static> {}
6216
6217 #[repr(transparent)]
6218 pub struct ConnectorRouterRouteResponse {
6219 pub(crate) raw: ::fidl_next::RawWireUnion,
6220 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6221 }
6222
6223 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
6224 type Owned<'de> = ConnectorRouterRouteResponse;
6225
6226 #[inline]
6227 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6228 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6229 ::fidl_next::RawWireUnion::zero_padding(raw);
6230 }
6231 }
6232
6233 impl ConnectorRouterRouteResponse {
6234 pub fn is_some(&self) -> bool {
6235 self.raw.is_some()
6236 }
6237
6238 pub fn is_none(&self) -> bool {
6239 self.raw.is_none()
6240 }
6241
6242 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
6243 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6244 }
6245
6246 pub fn into_option(
6247 self,
6248 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
6249 if self.is_some() {
6250 Some(crate::wire::ConnectorRouterRouteResponse {
6251 raw: self.raw,
6252 _phantom: ::core::marker::PhantomData,
6253 })
6254 } else {
6255 None
6256 }
6257 }
6258 }
6259
6260 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
6261 where
6262 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6263 ___D: ::fidl_next::fuchsia::HandleDecoder,
6264 {
6265 fn decode(
6266 mut slot: ::fidl_next::Slot<'_, Self>,
6267 decoder: &mut ___D,
6268 _: (),
6269 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6270 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6271 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6272 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
6273 raw,
6274 decoder,
6275 (),
6276 )?,
6277
6278 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6279 raw,
6280 decoder,
6281 (),
6282 )?,
6283
6284 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6285 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6286 }
6287
6288 Ok(())
6289 }
6290 }
6291
6292 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
6293 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6294 self.as_ref().fmt(f)
6295 }
6296 }
6297
6298 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
6299 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
6300 }
6301
6302 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
6303
6304 #[repr(transparent)]
6305 pub struct DataRouterRouteResponse<'de> {
6306 pub(crate) raw: ::fidl_next::RawWireUnion,
6307 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6308 }
6309
6310 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
6311 type Owned<'de> = DataRouterRouteResponse<'de>;
6312
6313 #[inline]
6314 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6315 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6316 ::fidl_next::RawWireUnion::zero_padding(raw);
6317 }
6318 }
6319
6320 impl<'de> DataRouterRouteResponse<'de> {
6321 pub fn is_some(&self) -> bool {
6322 self.raw.is_some()
6323 }
6324
6325 pub fn is_none(&self) -> bool {
6326 self.raw.is_none()
6327 }
6328
6329 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
6330 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6331 }
6332
6333 pub fn into_option(
6334 self,
6335 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
6336 if self.is_some() {
6337 Some(crate::wire::DataRouterRouteResponse {
6338 raw: self.raw,
6339 _phantom: ::core::marker::PhantomData,
6340 })
6341 } else {
6342 None
6343 }
6344 }
6345 }
6346
6347 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
6348 where
6349 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6350 ___D: ::fidl_next::Decoder,
6351 ___D: ::fidl_next::fuchsia::HandleDecoder,
6352 {
6353 fn decode(
6354 mut slot: ::fidl_next::Slot<'_, Self>,
6355 decoder: &mut ___D,
6356 _: (),
6357 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6358 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6359 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6360 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
6361 raw,
6362 decoder,
6363 (),
6364 )?,
6365
6366 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
6367 raw,
6368 decoder,
6369 (),
6370 )?,
6371
6372 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6373 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
6374 }
6375
6376 Ok(())
6377 }
6378 }
6379
6380 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
6381 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6382 self.as_ref().fmt(f)
6383 }
6384 }
6385
6386 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
6387 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
6388 }
6389
6390 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
6391
6392 #[repr(transparent)]
6393 pub struct DictionaryRouterRouteResponse {
6394 pub(crate) raw: ::fidl_next::RawWireUnion,
6395 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6396 }
6397
6398 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
6399 type Owned<'de> = DictionaryRouterRouteResponse;
6400
6401 #[inline]
6402 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6403 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6404 ::fidl_next::RawWireUnion::zero_padding(raw);
6405 }
6406 }
6407
6408 impl DictionaryRouterRouteResponse {
6409 pub fn is_some(&self) -> bool {
6410 self.raw.is_some()
6411 }
6412
6413 pub fn is_none(&self) -> bool {
6414 self.raw.is_none()
6415 }
6416
6417 pub fn as_ref(
6418 &self,
6419 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
6420 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6421 }
6422
6423 pub fn into_option(
6424 self,
6425 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
6426 if self.is_some() {
6427 Some(crate::wire::DictionaryRouterRouteResponse {
6428 raw: self.raw,
6429 _phantom: ::core::marker::PhantomData,
6430 })
6431 } else {
6432 None
6433 }
6434 }
6435 }
6436
6437 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
6438 where
6439 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6440 ___D: ::fidl_next::fuchsia::HandleDecoder,
6441 {
6442 fn decode(
6443 mut slot: ::fidl_next::Slot<'_, Self>,
6444 decoder: &mut ___D,
6445 _: (),
6446 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6447 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6448 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6449 1 => {
6450 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
6451 raw,
6452 decoder,
6453 (),
6454 )?
6455 }
6456
6457 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6458 raw,
6459 decoder,
6460 (),
6461 )?,
6462
6463 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6464 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6465 }
6466
6467 Ok(())
6468 }
6469 }
6470
6471 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
6472 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6473 self.as_ref().fmt(f)
6474 }
6475 }
6476
6477 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
6478 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
6479 }
6480
6481 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
6482
6483 #[repr(transparent)]
6484 pub struct DirConnectorRouterRouteResponse {
6485 pub(crate) raw: ::fidl_next::RawWireUnion,
6486 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6487 }
6488
6489 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
6490 type Owned<'de> = DirConnectorRouterRouteResponse;
6491
6492 #[inline]
6493 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6494 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6495 ::fidl_next::RawWireUnion::zero_padding(raw);
6496 }
6497 }
6498
6499 impl DirConnectorRouterRouteResponse {
6500 pub fn is_some(&self) -> bool {
6501 self.raw.is_some()
6502 }
6503
6504 pub fn is_none(&self) -> bool {
6505 self.raw.is_none()
6506 }
6507
6508 pub fn as_ref(
6509 &self,
6510 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
6511 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6512 }
6513
6514 pub fn into_option(
6515 self,
6516 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
6517 if self.is_some() {
6518 Some(crate::wire::DirConnectorRouterRouteResponse {
6519 raw: self.raw,
6520 _phantom: ::core::marker::PhantomData,
6521 })
6522 } else {
6523 None
6524 }
6525 }
6526 }
6527
6528 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
6529 where
6530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6531 ___D: ::fidl_next::fuchsia::HandleDecoder,
6532 {
6533 fn decode(
6534 mut slot: ::fidl_next::Slot<'_, Self>,
6535 decoder: &mut ___D,
6536 _: (),
6537 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6538 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6539 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6540 1 => {
6541 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
6542 raw,
6543 decoder,
6544 (),
6545 )?
6546 }
6547
6548 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6549 raw,
6550 decoder,
6551 (),
6552 )?,
6553
6554 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6555 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6556 }
6557
6558 Ok(())
6559 }
6560 }
6561
6562 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
6563 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6564 self.as_ref().fmt(f)
6565 }
6566 }
6567
6568 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
6569 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
6570 }
6571
6572 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
6573
6574 #[repr(transparent)]
6575 pub struct DirEntryRouterRouteResponse {
6576 pub(crate) raw: ::fidl_next::RawWireUnion,
6577 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6578 }
6579
6580 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
6581 type Owned<'de> = DirEntryRouterRouteResponse;
6582
6583 #[inline]
6584 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6585 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6586 ::fidl_next::RawWireUnion::zero_padding(raw);
6587 }
6588 }
6589
6590 impl DirEntryRouterRouteResponse {
6591 pub fn is_some(&self) -> bool {
6592 self.raw.is_some()
6593 }
6594
6595 pub fn is_none(&self) -> bool {
6596 self.raw.is_none()
6597 }
6598
6599 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
6600 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6601 }
6602
6603 pub fn into_option(
6604 self,
6605 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
6606 if self.is_some() {
6607 Some(crate::wire::DirEntryRouterRouteResponse {
6608 raw: self.raw,
6609 _phantom: ::core::marker::PhantomData,
6610 })
6611 } else {
6612 None
6613 }
6614 }
6615 }
6616
6617 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
6618 where
6619 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6620 ___D: ::fidl_next::fuchsia::HandleDecoder,
6621 {
6622 fn decode(
6623 mut slot: ::fidl_next::Slot<'_, Self>,
6624 decoder: &mut ___D,
6625 _: (),
6626 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6627 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6628 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6629 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
6630 raw,
6631 decoder,
6632 (),
6633 )?,
6634
6635 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6636 raw,
6637 decoder,
6638 (),
6639 )?,
6640
6641 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6642 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6643 }
6644
6645 Ok(())
6646 }
6647 }
6648
6649 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
6650 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6651 self.as_ref().fmt(f)
6652 }
6653 }
6654
6655 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
6656 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
6657 }
6658
6659 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
6660
6661 #[repr(transparent)]
6662 pub struct DirectoryRouterRouteResponse {
6663 pub(crate) raw: ::fidl_next::RawWireUnion,
6664 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6665 }
6666
6667 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
6668 type Owned<'de> = DirectoryRouterRouteResponse;
6669
6670 #[inline]
6671 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6672 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6673 ::fidl_next::RawWireUnion::zero_padding(raw);
6674 }
6675 }
6676
6677 impl DirectoryRouterRouteResponse {
6678 pub fn is_some(&self) -> bool {
6679 self.raw.is_some()
6680 }
6681
6682 pub fn is_none(&self) -> bool {
6683 self.raw.is_none()
6684 }
6685
6686 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
6687 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6688 }
6689
6690 pub fn into_option(
6691 self,
6692 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
6693 if self.is_some() {
6694 Some(crate::wire::DirectoryRouterRouteResponse {
6695 raw: self.raw,
6696 _phantom: ::core::marker::PhantomData,
6697 })
6698 } else {
6699 None
6700 }
6701 }
6702 }
6703
6704 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
6705 where
6706 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6707 ___D: ::fidl_next::fuchsia::HandleDecoder,
6708 {
6709 fn decode(
6710 mut slot: ::fidl_next::Slot<'_, Self>,
6711 decoder: &mut ___D,
6712 _: (),
6713 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6714 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6715 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6716 1 => ::fidl_next::RawWireUnion::decode_as_static::<
6717 ___D,
6718 ::fidl_next::ClientEnd<
6719 ::fidl_next_fuchsia_io::Directory,
6720 ::fidl_next::fuchsia::WireChannel,
6721 >,
6722 >(raw, decoder, ())?,
6723
6724 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6725 raw,
6726 decoder,
6727 (),
6728 )?,
6729
6730 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6731 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6732 }
6733
6734 Ok(())
6735 }
6736 }
6737
6738 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
6739 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6740 self.as_ref().fmt(f)
6741 }
6742 }
6743
6744 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
6745 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
6746 }
6747
6748 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
6749}
6750
6751pub mod generic {
6752
6753 pub use fidl_next_common_fuchsia_component_sandbox::generic::*;
6754
6755 pub struct DictionaryRef<T0> {
6756 pub token: T0,
6757 }
6758
6759 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef<T0>
6760 where
6761 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6762 ___E: ::fidl_next::fuchsia::HandleEncoder,
6763 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
6764 {
6765 #[inline]
6766 fn encode(
6767 self,
6768 encoder_: &mut ___E,
6769 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
6770 _: (),
6771 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6772 ::fidl_next::munge! {
6773 let crate::wire::DictionaryRef {
6774
6775 token,
6776
6777 } = out_;
6778 }
6779
6780 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
6781
6782 Ok(())
6783 }
6784 }
6785
6786 pub struct Connector<T0> {
6787 pub token: T0,
6788 }
6789
6790 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector<T0>
6791 where
6792 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6793 ___E: ::fidl_next::fuchsia::HandleEncoder,
6794 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
6795 {
6796 #[inline]
6797 fn encode(
6798 self,
6799 encoder_: &mut ___E,
6800 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
6801 _: (),
6802 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6803 ::fidl_next::munge! {
6804 let crate::wire::Connector {
6805
6806 token,
6807
6808 } = out_;
6809 }
6810
6811 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
6812
6813 Ok(())
6814 }
6815 }
6816
6817 pub struct DirConnector<T0> {
6818 pub token: T0,
6819 }
6820
6821 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector<T0>
6822 where
6823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6824 ___E: ::fidl_next::fuchsia::HandleEncoder,
6825 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
6826 {
6827 #[inline]
6828 fn encode(
6829 self,
6830 encoder_: &mut ___E,
6831 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
6832 _: (),
6833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6834 ::fidl_next::munge! {
6835 let crate::wire::DirConnector {
6836
6837 token,
6838
6839 } = out_;
6840 }
6841
6842 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
6843
6844 Ok(())
6845 }
6846 }
6847
6848 pub struct DirEntry<T0> {
6849 pub token: T0,
6850 }
6851
6852 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry<T0>
6853 where
6854 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6855 ___E: ::fidl_next::fuchsia::HandleEncoder,
6856 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
6857 {
6858 #[inline]
6859 fn encode(
6860 self,
6861 encoder_: &mut ___E,
6862 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
6863 _: (),
6864 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6865 ::fidl_next::munge! {
6866 let crate::wire::DirEntry {
6867
6868 token,
6869
6870 } = out_;
6871 }
6872
6873 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
6874
6875 Ok(())
6876 }
6877 }
6878
6879 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
6880 pub id: T0,
6881
6882 pub receiver: T1,
6883 }
6884
6885 unsafe impl<___E, T0, T1>
6886 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
6887 for CapabilityStoreConnectorCreateRequest<T0, T1>
6888 where
6889 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6890 ___E: ::fidl_next::fuchsia::HandleEncoder,
6891 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
6892 T1: ::fidl_next::Encode<
6893 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
6894 ___E,
6895 >,
6896 {
6897 #[inline]
6898 fn encode(
6899 self,
6900 encoder_: &mut ___E,
6901 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
6902 _: (),
6903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6904 ::fidl_next::munge! {
6905 let crate::wire::CapabilityStoreConnectorCreateRequest {
6906
6907 id,
6908 receiver,
6909
6910 } = out_;
6911 }
6912
6913 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
6914
6915 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
6916
6917 Ok(())
6918 }
6919 }
6920
6921 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
6922 pub id: T0,
6923
6924 pub server_end: T1,
6925 }
6926
6927 unsafe impl<___E, T0, T1>
6928 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
6929 for CapabilityStoreConnectorOpenRequest<T0, T1>
6930 where
6931 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6932 ___E: ::fidl_next::fuchsia::HandleEncoder,
6933 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
6934 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
6935 {
6936 #[inline]
6937 fn encode(
6938 self,
6939 encoder_: &mut ___E,
6940 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
6941 _: (),
6942 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6943 ::fidl_next::munge! {
6944 let crate::wire::CapabilityStoreConnectorOpenRequest {
6945
6946 id,
6947 server_end,
6948
6949 } = out_;
6950 }
6951
6952 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
6953
6954 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
6955
6956 Ok(())
6957 }
6958 }
6959
6960 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
6961 pub id: T0,
6962
6963 pub client_end: T1,
6964 }
6965
6966 unsafe impl<___E, T0, T1>
6967 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
6968 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
6969 where
6970 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6971 ___E: ::fidl_next::fuchsia::HandleEncoder,
6972 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
6973 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
6974 {
6975 #[inline]
6976 fn encode(
6977 self,
6978 encoder_: &mut ___E,
6979 out_: &mut ::core::mem::MaybeUninit<
6980 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
6981 >,
6982 _: (),
6983 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6984 ::fidl_next::munge! {
6985 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
6986
6987 id,
6988 client_end,
6989
6990 } = out_;
6991 }
6992
6993 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
6994
6995 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
6996
6997 Ok(())
6998 }
6999 }
7000
7001 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
7002 pub id: T0,
7003
7004 pub server_end: T1,
7005 }
7006
7007 unsafe impl<___E, T0, T1>
7008 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
7009 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
7010 where
7011 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7012 ___E: ::fidl_next::fuchsia::HandleEncoder,
7013 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7014 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7015 {
7016 #[inline]
7017 fn encode(
7018 self,
7019 encoder_: &mut ___E,
7020 out_: &mut ::core::mem::MaybeUninit<
7021 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
7022 >,
7023 _: (),
7024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7025 ::fidl_next::munge! {
7026 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
7027
7028 id,
7029 server_end,
7030
7031 } = out_;
7032 }
7033
7034 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7035
7036 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7037
7038 Ok(())
7039 }
7040 }
7041
7042 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
7043 pub id: T0,
7044
7045 pub iterator: T1,
7046 }
7047
7048 unsafe impl<___E, T0, T1>
7049 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
7050 for CapabilityStoreDictionaryKeysRequest<T0, T1>
7051 where
7052 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7053 ___E: ::fidl_next::fuchsia::HandleEncoder,
7054 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7055 T1: ::fidl_next::Encode<
7056 ::fidl_next::ServerEnd<
7057 crate::DictionaryKeysIterator,
7058 ::fidl_next::fuchsia::WireChannel,
7059 >,
7060 ___E,
7061 >,
7062 {
7063 #[inline]
7064 fn encode(
7065 self,
7066 encoder_: &mut ___E,
7067 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
7068 _: (),
7069 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7070 ::fidl_next::munge! {
7071 let crate::wire::CapabilityStoreDictionaryKeysRequest {
7072
7073 id,
7074 iterator,
7075
7076 } = out_;
7077 }
7078
7079 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7080
7081 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7082
7083 Ok(())
7084 }
7085 }
7086
7087 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
7088 pub id: T0,
7089
7090 pub iterator: T1,
7091 }
7092
7093 unsafe impl<___E, T0, T1>
7094 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
7095 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
7096 where
7097 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7098 ___E: ::fidl_next::fuchsia::HandleEncoder,
7099 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7100 T1: ::fidl_next::Encode<
7101 ::fidl_next::ServerEnd<
7102 crate::DictionaryEnumerateIterator,
7103 ::fidl_next::fuchsia::WireChannel,
7104 >,
7105 ___E,
7106 >,
7107 {
7108 #[inline]
7109 fn encode(
7110 self,
7111 encoder_: &mut ___E,
7112 out_: &mut ::core::mem::MaybeUninit<
7113 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
7114 >,
7115 _: (),
7116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7117 ::fidl_next::munge! {
7118 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
7119
7120 id,
7121 iterator,
7122
7123 } = out_;
7124 }
7125
7126 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7127
7128 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7129
7130 Ok(())
7131 }
7132 }
7133
7134 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
7135 pub id: T0,
7136
7137 pub iterator: T1,
7138 }
7139
7140 unsafe impl<___E, T0, T1>
7141 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
7142 for CapabilityStoreDictionaryDrainRequest<T0, T1>
7143 where
7144 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7145 ___E: ::fidl_next::fuchsia::HandleEncoder,
7146 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7147 T1: ::fidl_next::Encode<
7148 ::fidl_next::ServerEnd<
7149 crate::DictionaryDrainIterator,
7150 ::fidl_next::fuchsia::WireOptionalChannel,
7151 >,
7152 ___E,
7153 >,
7154 {
7155 #[inline]
7156 fn encode(
7157 self,
7158 encoder_: &mut ___E,
7159 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
7160 _: (),
7161 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7162 ::fidl_next::munge! {
7163 let crate::wire::CapabilityStoreDictionaryDrainRequest {
7164
7165 id,
7166 iterator,
7167
7168 } = out_;
7169 }
7170
7171 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7172
7173 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7174
7175 Ok(())
7176 }
7177 }
7178
7179 pub struct CapabilityStoreExportResponse<T0> {
7180 pub capability: T0,
7181 }
7182
7183 unsafe impl<___E, T0>
7184 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
7185 for CapabilityStoreExportResponse<T0>
7186 where
7187 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7188 ___E: ::fidl_next::Encoder,
7189 ___E: ::fidl_next::fuchsia::HandleEncoder,
7190 T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
7191 {
7192 #[inline]
7193 fn encode(
7194 self,
7195 encoder_: &mut ___E,
7196 out_: &mut ::core::mem::MaybeUninit<
7197 crate::wire::CapabilityStoreExportResponse<'static>,
7198 >,
7199 _: (),
7200 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7201 ::fidl_next::munge! {
7202 let crate::wire::CapabilityStoreExportResponse {
7203
7204 capability,
7205
7206 } = out_;
7207 }
7208
7209 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7210
7211 Ok(())
7212 }
7213 }
7214
7215 pub struct CapabilityStoreImportRequest<T0, T1> {
7216 pub id: T0,
7217
7218 pub capability: T1,
7219 }
7220
7221 unsafe impl<___E, T0, T1>
7222 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
7223 for CapabilityStoreImportRequest<T0, T1>
7224 where
7225 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7226 ___E: ::fidl_next::Encoder,
7227 ___E: ::fidl_next::fuchsia::HandleEncoder,
7228 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7229 T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
7230 {
7231 #[inline]
7232 fn encode(
7233 self,
7234 encoder_: &mut ___E,
7235 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
7236 _: (),
7237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7238 ::fidl_next::munge! {
7239 let crate::wire::CapabilityStoreImportRequest {
7240
7241 id,
7242 capability,
7243
7244 } = out_;
7245 }
7246
7247 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7248
7249 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7250
7251 Ok(())
7252 }
7253 }
7254
7255 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
7256 pub id: T0,
7257
7258 pub receiver: T1,
7259 }
7260
7261 unsafe impl<___E, T0, T1>
7262 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
7263 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
7264 where
7265 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7266 ___E: ::fidl_next::fuchsia::HandleEncoder,
7267 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7268 T1: ::fidl_next::Encode<
7269 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
7270 ___E,
7271 >,
7272 {
7273 #[inline]
7274 fn encode(
7275 self,
7276 encoder_: &mut ___E,
7277 out_: &mut ::core::mem::MaybeUninit<
7278 crate::wire::CapabilityStoreDirConnectorCreateRequest,
7279 >,
7280 _: (),
7281 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7282 ::fidl_next::munge! {
7283 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
7284
7285 id,
7286 receiver,
7287
7288 } = out_;
7289 }
7290
7291 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7292
7293 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
7294
7295 Ok(())
7296 }
7297 }
7298
7299 pub struct CapabilityStoreDirConnectorOpenRequest<T0, T1> {
7300 pub id: T0,
7301
7302 pub server_end: T1,
7303 }
7304
7305 unsafe impl<___E, T0, T1>
7306 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest, ___E>
7307 for CapabilityStoreDirConnectorOpenRequest<T0, T1>
7308 where
7309 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7310 ___E: ::fidl_next::fuchsia::HandleEncoder,
7311 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7312 T1: ::fidl_next::Encode<
7313 ::fidl_next::ServerEnd<
7314 ::fidl_next_fuchsia_io::Directory,
7315 ::fidl_next::fuchsia::WireChannel,
7316 >,
7317 ___E,
7318 >,
7319 {
7320 #[inline]
7321 fn encode(
7322 self,
7323 encoder_: &mut ___E,
7324 out_: &mut ::core::mem::MaybeUninit<
7325 crate::wire::CapabilityStoreDirConnectorOpenRequest,
7326 >,
7327 _: (),
7328 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7329 ::fidl_next::munge! {
7330 let crate::wire::CapabilityStoreDirConnectorOpenRequest {
7331
7332 id,
7333 server_end,
7334
7335 } = out_;
7336 }
7337
7338 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7339
7340 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7341
7342 Ok(())
7343 }
7344 }
7345
7346 pub struct InstanceToken<T0> {
7347 pub token: T0,
7348 }
7349
7350 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken<T0>
7351 where
7352 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7353 ___E: ::fidl_next::fuchsia::HandleEncoder,
7354 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7355 {
7356 #[inline]
7357 fn encode(
7358 self,
7359 encoder_: &mut ___E,
7360 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
7361 _: (),
7362 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7363 ::fidl_next::munge! {
7364 let crate::wire::InstanceToken {
7365
7366 token,
7367
7368 } = out_;
7369 }
7370
7371 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7372
7373 Ok(())
7374 }
7375 }
7376
7377 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
7378 pub items: T0,
7379
7380 pub end_id: T1,
7381 }
7382
7383 unsafe impl<___E, T0, T1>
7384 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
7385 for DictionaryDrainIteratorGetNextResponse<T0, T1>
7386 where
7387 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7388 ___E: ::fidl_next::Encoder,
7389 ___E: ::fidl_next::fuchsia::HandleEncoder,
7390 T0: ::fidl_next::Encode<
7391 ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
7392 ___E,
7393 >,
7394 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7395 {
7396 #[inline]
7397 fn encode(
7398 self,
7399 encoder_: &mut ___E,
7400 out_: &mut ::core::mem::MaybeUninit<
7401 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
7402 >,
7403 _: (),
7404 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7405 ::fidl_next::munge! {
7406 let crate::wire::DictionaryDrainIteratorGetNextResponse {
7407
7408 items,
7409 end_id,
7410
7411 } = out_;
7412 }
7413
7414 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
7415
7416 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
7417
7418 Ok(())
7419 }
7420 }
7421
7422 pub struct DictionaryOptionalItem<T0, T1> {
7423 pub key: T0,
7424
7425 pub value: T1,
7426 }
7427
7428 unsafe impl<___E, T0, T1>
7429 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
7430 for DictionaryOptionalItem<T0, T1>
7431 where
7432 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7433 ___E: ::fidl_next::Encoder,
7434 ___E: ::fidl_next::fuchsia::HandleEncoder,
7435 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
7436 T1: ::fidl_next::Encode<
7437 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
7438 ___E,
7439 >,
7440 {
7441 #[inline]
7442 fn encode(
7443 self,
7444 encoder_: &mut ___E,
7445 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
7446 _: (),
7447 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7448 ::fidl_next::munge! {
7449 let crate::wire::DictionaryOptionalItem {
7450
7451 key,
7452 value,
7453
7454 } = out_;
7455 }
7456
7457 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
7458
7459 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
7460
7461 Ok(())
7462 }
7463 }
7464
7465 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
7466 pub items: T0,
7467
7468 pub end_id: T1,
7469 }
7470
7471 unsafe impl<___E, T0, T1>
7472 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
7473 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
7474 where
7475 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7476 ___E: ::fidl_next::Encoder,
7477 ___E: ::fidl_next::fuchsia::HandleEncoder,
7478 T0: ::fidl_next::Encode<
7479 ::fidl_next::WireVector<'static, crate::wire::DictionaryOptionalItem<'static>>,
7480 ___E,
7481 >,
7482 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7483 {
7484 #[inline]
7485 fn encode(
7486 self,
7487 encoder_: &mut ___E,
7488 out_: &mut ::core::mem::MaybeUninit<
7489 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
7490 >,
7491 _: (),
7492 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7493 ::fidl_next::munge! {
7494 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
7495
7496 items,
7497 end_id,
7498
7499 } = out_;
7500 }
7501
7502 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
7503
7504 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
7505
7506 Ok(())
7507 }
7508 }
7509
7510 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
7511 pub keys: T0,
7512 }
7513
7514 unsafe impl<___E, T0>
7515 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
7516 for DictionaryKeysIteratorGetNextResponse<T0>
7517 where
7518 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7519 ___E: ::fidl_next::Encoder,
7520 ___E: ::fidl_next::fuchsia::HandleEncoder,
7521 T0: ::fidl_next::Encode<
7522 ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
7523 ___E,
7524 >,
7525 {
7526 #[inline]
7527 fn encode(
7528 self,
7529 encoder_: &mut ___E,
7530 out_: &mut ::core::mem::MaybeUninit<
7531 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
7532 >,
7533 _: (),
7534 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7535 ::fidl_next::munge! {
7536 let crate::wire::DictionaryKeysIteratorGetNextResponse {
7537
7538 keys,
7539
7540 } = out_;
7541 }
7542
7543 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
7544
7545 Ok(())
7546 }
7547 }
7548
7549 pub struct DirReceiverReceiveRequest<T0> {
7550 pub channel: T0,
7551 }
7552
7553 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest, ___E>
7554 for DirReceiverReceiveRequest<T0>
7555 where
7556 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7557 ___E: ::fidl_next::fuchsia::HandleEncoder,
7558 T0: ::fidl_next::Encode<
7559 ::fidl_next::ServerEnd<
7560 ::fidl_next_fuchsia_io::Directory,
7561 ::fidl_next::fuchsia::WireChannel,
7562 >,
7563 ___E,
7564 >,
7565 {
7566 #[inline]
7567 fn encode(
7568 self,
7569 encoder_: &mut ___E,
7570 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest>,
7571 _: (),
7572 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7573 ::fidl_next::munge! {
7574 let crate::wire::DirReceiverReceiveRequest {
7575
7576 channel,
7577
7578 } = out_;
7579 }
7580
7581 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7582
7583 Ok(())
7584 }
7585 }
7586
7587 pub struct ProtocolPayload<T0> {
7588 pub channel: T0,
7589 }
7590
7591 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
7592 for ProtocolPayload<T0>
7593 where
7594 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7595 ___E: ::fidl_next::fuchsia::HandleEncoder,
7596 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7597 {
7598 #[inline]
7599 fn encode(
7600 self,
7601 encoder_: &mut ___E,
7602 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
7603 _: (),
7604 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7605 ::fidl_next::munge! {
7606 let crate::wire::ProtocolPayload {
7607
7608 channel,
7609
7610 } = out_;
7611 }
7612
7613 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7614
7615 Ok(())
7616 }
7617 }
7618}
7619
7620pub use self::natural::*;
7621
7622#[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"]
7624#[derive(PartialEq, Debug)]
7625pub struct CapabilityStore;
7626
7627impl ::fidl_next::Discoverable for CapabilityStore {
7628 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
7629}
7630
7631#[cfg(target_os = "fuchsia")]
7632impl ::fidl_next::HasTransport for CapabilityStore {
7633 type Transport = ::fidl_next::fuchsia::zx::Channel;
7634}
7635
7636pub mod capability_store {
7637 pub mod prelude {
7638 pub use crate::{
7639 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
7640 capability_store,
7641 };
7642
7643 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
7644
7645 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
7646
7647 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
7648
7649 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
7650
7651 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
7652
7653 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
7654
7655 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
7656
7657 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
7658
7659 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
7660
7661 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
7662
7663 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
7664
7665 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
7666
7667 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
7668
7669 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
7670
7671 pub use crate::natural::CapabilityStoreDropRequest;
7672
7673 pub use crate::natural::CapabilityStoreDuplicateRequest;
7674
7675 pub use crate::natural::CapabilityStoreError;
7676
7677 pub use crate::natural::CapabilityStoreExportRequest;
7678
7679 pub use crate::natural::CapabilityStoreImportRequest;
7680
7681 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
7682
7683 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
7684
7685 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
7686
7687 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
7688
7689 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
7690
7691 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
7692
7693 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
7694
7695 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
7696
7697 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
7698
7699 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
7700
7701 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
7702
7703 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
7704
7705 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
7706
7707 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
7708
7709 pub use crate::natural::CapabilityStoreDropResponse;
7710
7711 pub use crate::natural::CapabilityStoreDuplicateResponse;
7712
7713 pub use crate::natural::CapabilityStoreExportResponse;
7714
7715 pub use crate::natural::CapabilityStoreImportResponse;
7716 }
7717
7718 pub struct Duplicate;
7719
7720 impl ::fidl_next::Method for Duplicate {
7721 const ORDINAL: u64 = 6727592627741008260;
7722 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7723 ::fidl_next::protocol::Flexibility::Flexible;
7724
7725 type Protocol = crate::CapabilityStore;
7726
7727 type Request = crate::wire::CapabilityStoreDuplicateRequest;
7728 }
7729
7730 impl ::fidl_next::TwoWayMethod for Duplicate {
7731 type Response = ::fidl_next::WireFlexibleResult<
7732 'static,
7733 crate::wire::CapabilityStoreDuplicateResponse,
7734 crate::wire::CapabilityStoreError,
7735 >;
7736 }
7737
7738 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
7739 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7740
7741 fn respond(response: ___R) -> Self::Output {
7742 ::fidl_next::FlexibleResult::Ok(response)
7743 }
7744 }
7745
7746 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
7747 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7748
7749 fn respond_err(response: ___R) -> Self::Output {
7750 ::fidl_next::FlexibleResult::Err(response)
7751 }
7752 }
7753
7754 pub struct Drop;
7755
7756 impl ::fidl_next::Method for Drop {
7757 const ORDINAL: u64 = 753328233834620249;
7758 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7759 ::fidl_next::protocol::Flexibility::Flexible;
7760
7761 type Protocol = crate::CapabilityStore;
7762
7763 type Request = crate::wire::CapabilityStoreDropRequest;
7764 }
7765
7766 impl ::fidl_next::TwoWayMethod for Drop {
7767 type Response = ::fidl_next::WireFlexibleResult<
7768 'static,
7769 crate::wire::CapabilityStoreDropResponse,
7770 crate::wire::CapabilityStoreError,
7771 >;
7772 }
7773
7774 impl<___R> ::fidl_next::Respond<___R> for Drop {
7775 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7776
7777 fn respond(response: ___R) -> Self::Output {
7778 ::fidl_next::FlexibleResult::Ok(response)
7779 }
7780 }
7781
7782 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
7783 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7784
7785 fn respond_err(response: ___R) -> Self::Output {
7786 ::fidl_next::FlexibleResult::Err(response)
7787 }
7788 }
7789
7790 pub struct Export;
7791
7792 impl ::fidl_next::Method for Export {
7793 const ORDINAL: u64 = 226159162093533951;
7794 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7795 ::fidl_next::protocol::Flexibility::Flexible;
7796
7797 type Protocol = crate::CapabilityStore;
7798
7799 type Request = crate::wire::CapabilityStoreExportRequest;
7800 }
7801
7802 impl ::fidl_next::TwoWayMethod for Export {
7803 type Response = ::fidl_next::WireFlexibleResult<
7804 'static,
7805 crate::wire::CapabilityStoreExportResponse<'static>,
7806 crate::wire::CapabilityStoreError,
7807 >;
7808 }
7809
7810 impl<___R> ::fidl_next::Respond<___R> for Export {
7811 type Output = ::fidl_next::FlexibleResult<
7812 crate::generic::CapabilityStoreExportResponse<___R>,
7813 ::fidl_next::util::Never,
7814 >;
7815
7816 fn respond(response: ___R) -> Self::Output {
7817 ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
7818 capability: response,
7819 })
7820 }
7821 }
7822
7823 impl<___R> ::fidl_next::RespondErr<___R> for Export {
7824 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7825
7826 fn respond_err(response: ___R) -> Self::Output {
7827 ::fidl_next::FlexibleResult::Err(response)
7828 }
7829 }
7830
7831 pub struct Import;
7832
7833 impl ::fidl_next::Method for Import {
7834 const ORDINAL: u64 = 2276030276116435867;
7835 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7836 ::fidl_next::protocol::Flexibility::Flexible;
7837
7838 type Protocol = crate::CapabilityStore;
7839
7840 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
7841 }
7842
7843 impl ::fidl_next::TwoWayMethod for Import {
7844 type Response = ::fidl_next::WireFlexibleResult<
7845 'static,
7846 crate::wire::CapabilityStoreImportResponse,
7847 crate::wire::CapabilityStoreError,
7848 >;
7849 }
7850
7851 impl<___R> ::fidl_next::Respond<___R> for Import {
7852 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7853
7854 fn respond(response: ___R) -> Self::Output {
7855 ::fidl_next::FlexibleResult::Ok(response)
7856 }
7857 }
7858
7859 impl<___R> ::fidl_next::RespondErr<___R> for Import {
7860 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7861
7862 fn respond_err(response: ___R) -> Self::Output {
7863 ::fidl_next::FlexibleResult::Err(response)
7864 }
7865 }
7866
7867 pub struct ConnectorCreate;
7868
7869 impl ::fidl_next::Method for ConnectorCreate {
7870 const ORDINAL: u64 = 2979461408102095909;
7871 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7872 ::fidl_next::protocol::Flexibility::Flexible;
7873
7874 type Protocol = crate::CapabilityStore;
7875
7876 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
7877 }
7878
7879 impl ::fidl_next::TwoWayMethod for ConnectorCreate {
7880 type Response = ::fidl_next::WireFlexibleResult<
7881 'static,
7882 crate::wire::CapabilityStoreConnectorCreateResponse,
7883 crate::wire::CapabilityStoreError,
7884 >;
7885 }
7886
7887 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
7888 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7889
7890 fn respond(response: ___R) -> Self::Output {
7891 ::fidl_next::FlexibleResult::Ok(response)
7892 }
7893 }
7894
7895 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
7896 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7897
7898 fn respond_err(response: ___R) -> Self::Output {
7899 ::fidl_next::FlexibleResult::Err(response)
7900 }
7901 }
7902
7903 pub struct ConnectorOpen;
7904
7905 impl ::fidl_next::Method for ConnectorOpen {
7906 const ORDINAL: u64 = 6016362336453278623;
7907 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7908 ::fidl_next::protocol::Flexibility::Flexible;
7909
7910 type Protocol = crate::CapabilityStore;
7911
7912 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
7913 }
7914
7915 impl ::fidl_next::TwoWayMethod for ConnectorOpen {
7916 type Response = ::fidl_next::WireFlexibleResult<
7917 'static,
7918 crate::wire::CapabilityStoreConnectorOpenResponse,
7919 crate::wire::CapabilityStoreError,
7920 >;
7921 }
7922
7923 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
7924 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7925
7926 fn respond(response: ___R) -> Self::Output {
7927 ::fidl_next::FlexibleResult::Ok(response)
7928 }
7929 }
7930
7931 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
7932 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7933
7934 fn respond_err(response: ___R) -> Self::Output {
7935 ::fidl_next::FlexibleResult::Err(response)
7936 }
7937 }
7938
7939 pub struct DirConnectorCreate;
7940
7941 impl ::fidl_next::Method for DirConnectorCreate {
7942 const ORDINAL: u64 = 1756747594275428795;
7943 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7944 ::fidl_next::protocol::Flexibility::Flexible;
7945
7946 type Protocol = crate::CapabilityStore;
7947
7948 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
7949 }
7950
7951 impl ::fidl_next::TwoWayMethod for DirConnectorCreate {
7952 type Response = ::fidl_next::WireFlexibleResult<
7953 'static,
7954 crate::wire::CapabilityStoreDirConnectorCreateResponse,
7955 crate::wire::CapabilityStoreError,
7956 >;
7957 }
7958
7959 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
7960 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7961
7962 fn respond(response: ___R) -> Self::Output {
7963 ::fidl_next::FlexibleResult::Ok(response)
7964 }
7965 }
7966
7967 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
7968 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7969
7970 fn respond_err(response: ___R) -> Self::Output {
7971 ::fidl_next::FlexibleResult::Err(response)
7972 }
7973 }
7974
7975 pub struct DirConnectorOpen;
7976
7977 impl ::fidl_next::Method for DirConnectorOpen {
7978 const ORDINAL: u64 = 6219704004220369153;
7979 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7980 ::fidl_next::protocol::Flexibility::Flexible;
7981
7982 type Protocol = crate::CapabilityStore;
7983
7984 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest;
7985 }
7986
7987 impl ::fidl_next::TwoWayMethod for DirConnectorOpen {
7988 type Response = ::fidl_next::WireFlexibleResult<
7989 'static,
7990 crate::wire::CapabilityStoreDirConnectorOpenResponse,
7991 crate::wire::CapabilityStoreError,
7992 >;
7993 }
7994
7995 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
7996 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7997
7998 fn respond(response: ___R) -> Self::Output {
7999 ::fidl_next::FlexibleResult::Ok(response)
8000 }
8001 }
8002
8003 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
8004 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8005
8006 fn respond_err(response: ___R) -> Self::Output {
8007 ::fidl_next::FlexibleResult::Err(response)
8008 }
8009 }
8010
8011 pub struct DictionaryCreate;
8012
8013 impl ::fidl_next::Method for DictionaryCreate {
8014 const ORDINAL: u64 = 7608770958894948499;
8015 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8016 ::fidl_next::protocol::Flexibility::Flexible;
8017
8018 type Protocol = crate::CapabilityStore;
8019
8020 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
8021 }
8022
8023 impl ::fidl_next::TwoWayMethod for DictionaryCreate {
8024 type Response = ::fidl_next::WireFlexibleResult<
8025 'static,
8026 crate::wire::CapabilityStoreDictionaryCreateResponse,
8027 crate::wire::CapabilityStoreError,
8028 >;
8029 }
8030
8031 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
8032 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8033
8034 fn respond(response: ___R) -> Self::Output {
8035 ::fidl_next::FlexibleResult::Ok(response)
8036 }
8037 }
8038
8039 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
8040 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8041
8042 fn respond_err(response: ___R) -> Self::Output {
8043 ::fidl_next::FlexibleResult::Err(response)
8044 }
8045 }
8046
8047 pub struct DictionaryLegacyImport;
8048
8049 impl ::fidl_next::Method for DictionaryLegacyImport {
8050 const ORDINAL: u64 = 8285893703432012383;
8051 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8052 ::fidl_next::protocol::Flexibility::Flexible;
8053
8054 type Protocol = crate::CapabilityStore;
8055
8056 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
8057 }
8058
8059 impl ::fidl_next::TwoWayMethod for DictionaryLegacyImport {
8060 type Response = ::fidl_next::WireFlexibleResult<
8061 'static,
8062 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
8063 crate::wire::CapabilityStoreError,
8064 >;
8065 }
8066
8067 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
8068 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8069
8070 fn respond(response: ___R) -> Self::Output {
8071 ::fidl_next::FlexibleResult::Ok(response)
8072 }
8073 }
8074
8075 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
8076 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8077
8078 fn respond_err(response: ___R) -> Self::Output {
8079 ::fidl_next::FlexibleResult::Err(response)
8080 }
8081 }
8082
8083 pub struct DictionaryLegacyExport;
8084
8085 impl ::fidl_next::Method for DictionaryLegacyExport {
8086 const ORDINAL: u64 = 4647175832683306445;
8087 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8088 ::fidl_next::protocol::Flexibility::Flexible;
8089
8090 type Protocol = crate::CapabilityStore;
8091
8092 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
8093 }
8094
8095 impl ::fidl_next::TwoWayMethod for DictionaryLegacyExport {
8096 type Response = ::fidl_next::WireFlexibleResult<
8097 'static,
8098 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
8099 crate::wire::CapabilityStoreError,
8100 >;
8101 }
8102
8103 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
8104 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8105
8106 fn respond(response: ___R) -> Self::Output {
8107 ::fidl_next::FlexibleResult::Ok(response)
8108 }
8109 }
8110
8111 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
8112 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8113
8114 fn respond_err(response: ___R) -> Self::Output {
8115 ::fidl_next::FlexibleResult::Err(response)
8116 }
8117 }
8118
8119 pub struct DictionaryInsert;
8120
8121 impl ::fidl_next::Method for DictionaryInsert {
8122 const ORDINAL: u64 = 8575443262986538023;
8123 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8124 ::fidl_next::protocol::Flexibility::Flexible;
8125
8126 type Protocol = crate::CapabilityStore;
8127
8128 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
8129 }
8130
8131 impl ::fidl_next::TwoWayMethod for DictionaryInsert {
8132 type Response = ::fidl_next::WireFlexibleResult<
8133 'static,
8134 crate::wire::CapabilityStoreDictionaryInsertResponse,
8135 crate::wire::CapabilityStoreError,
8136 >;
8137 }
8138
8139 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
8140 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8141
8142 fn respond(response: ___R) -> Self::Output {
8143 ::fidl_next::FlexibleResult::Ok(response)
8144 }
8145 }
8146
8147 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
8148 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8149
8150 fn respond_err(response: ___R) -> Self::Output {
8151 ::fidl_next::FlexibleResult::Err(response)
8152 }
8153 }
8154
8155 pub struct DictionaryGet;
8156
8157 impl ::fidl_next::Method for DictionaryGet {
8158 const ORDINAL: u64 = 5592951026866236882;
8159 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8160 ::fidl_next::protocol::Flexibility::Flexible;
8161
8162 type Protocol = crate::CapabilityStore;
8163
8164 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
8165 }
8166
8167 impl ::fidl_next::TwoWayMethod for DictionaryGet {
8168 type Response = ::fidl_next::WireFlexibleResult<
8169 'static,
8170 crate::wire::CapabilityStoreDictionaryGetResponse,
8171 crate::wire::CapabilityStoreError,
8172 >;
8173 }
8174
8175 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
8176 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8177
8178 fn respond(response: ___R) -> Self::Output {
8179 ::fidl_next::FlexibleResult::Ok(response)
8180 }
8181 }
8182
8183 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
8184 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8185
8186 fn respond_err(response: ___R) -> Self::Output {
8187 ::fidl_next::FlexibleResult::Err(response)
8188 }
8189 }
8190
8191 pub struct DictionaryRemove;
8192
8193 impl ::fidl_next::Method for DictionaryRemove {
8194 const ORDINAL: u64 = 343892214579320051;
8195 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8196 ::fidl_next::protocol::Flexibility::Flexible;
8197
8198 type Protocol = crate::CapabilityStore;
8199
8200 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
8201 }
8202
8203 impl ::fidl_next::TwoWayMethod for DictionaryRemove {
8204 type Response = ::fidl_next::WireFlexibleResult<
8205 'static,
8206 crate::wire::CapabilityStoreDictionaryRemoveResponse,
8207 crate::wire::CapabilityStoreError,
8208 >;
8209 }
8210
8211 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
8212 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8213
8214 fn respond(response: ___R) -> Self::Output {
8215 ::fidl_next::FlexibleResult::Ok(response)
8216 }
8217 }
8218
8219 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
8220 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8221
8222 fn respond_err(response: ___R) -> Self::Output {
8223 ::fidl_next::FlexibleResult::Err(response)
8224 }
8225 }
8226
8227 pub struct DictionaryCopy;
8228
8229 impl ::fidl_next::Method for DictionaryCopy {
8230 const ORDINAL: u64 = 3977783339739362383;
8231 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8232 ::fidl_next::protocol::Flexibility::Flexible;
8233
8234 type Protocol = crate::CapabilityStore;
8235
8236 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
8237 }
8238
8239 impl ::fidl_next::TwoWayMethod for DictionaryCopy {
8240 type Response = ::fidl_next::WireFlexibleResult<
8241 'static,
8242 crate::wire::CapabilityStoreDictionaryCopyResponse,
8243 crate::wire::CapabilityStoreError,
8244 >;
8245 }
8246
8247 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
8248 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8249
8250 fn respond(response: ___R) -> Self::Output {
8251 ::fidl_next::FlexibleResult::Ok(response)
8252 }
8253 }
8254
8255 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
8256 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8257
8258 fn respond_err(response: ___R) -> Self::Output {
8259 ::fidl_next::FlexibleResult::Err(response)
8260 }
8261 }
8262
8263 pub struct DictionaryKeys;
8264
8265 impl ::fidl_next::Method for DictionaryKeys {
8266 const ORDINAL: u64 = 597577248872787102;
8267 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8268 ::fidl_next::protocol::Flexibility::Flexible;
8269
8270 type Protocol = crate::CapabilityStore;
8271
8272 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
8273 }
8274
8275 impl ::fidl_next::TwoWayMethod for DictionaryKeys {
8276 type Response = ::fidl_next::WireFlexibleResult<
8277 'static,
8278 crate::wire::CapabilityStoreDictionaryKeysResponse,
8279 crate::wire::CapabilityStoreError,
8280 >;
8281 }
8282
8283 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
8284 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8285
8286 fn respond(response: ___R) -> Self::Output {
8287 ::fidl_next::FlexibleResult::Ok(response)
8288 }
8289 }
8290
8291 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
8292 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8293
8294 fn respond_err(response: ___R) -> Self::Output {
8295 ::fidl_next::FlexibleResult::Err(response)
8296 }
8297 }
8298
8299 pub struct DictionaryEnumerate;
8300
8301 impl ::fidl_next::Method for DictionaryEnumerate {
8302 const ORDINAL: u64 = 964467096271472193;
8303 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8304 ::fidl_next::protocol::Flexibility::Flexible;
8305
8306 type Protocol = crate::CapabilityStore;
8307
8308 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
8309 }
8310
8311 impl ::fidl_next::TwoWayMethod for DictionaryEnumerate {
8312 type Response = ::fidl_next::WireFlexibleResult<
8313 'static,
8314 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
8315 crate::wire::CapabilityStoreError,
8316 >;
8317 }
8318
8319 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
8320 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8321
8322 fn respond(response: ___R) -> Self::Output {
8323 ::fidl_next::FlexibleResult::Ok(response)
8324 }
8325 }
8326
8327 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
8328 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8329
8330 fn respond_err(response: ___R) -> Self::Output {
8331 ::fidl_next::FlexibleResult::Err(response)
8332 }
8333 }
8334
8335 pub struct DictionaryDrain;
8336
8337 impl ::fidl_next::Method for DictionaryDrain {
8338 const ORDINAL: u64 = 2928364469569621208;
8339 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8340 ::fidl_next::protocol::Flexibility::Flexible;
8341
8342 type Protocol = crate::CapabilityStore;
8343
8344 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
8345 }
8346
8347 impl ::fidl_next::TwoWayMethod for DictionaryDrain {
8348 type Response = ::fidl_next::WireFlexibleResult<
8349 'static,
8350 crate::wire::CapabilityStoreDictionaryDrainResponse,
8351 crate::wire::CapabilityStoreError,
8352 >;
8353 }
8354
8355 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
8356 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8357
8358 fn respond(response: ___R) -> Self::Output {
8359 ::fidl_next::FlexibleResult::Ok(response)
8360 }
8361 }
8362
8363 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
8364 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8365
8366 fn respond_err(response: ___R) -> Self::Output {
8367 ::fidl_next::FlexibleResult::Err(response)
8368 }
8369 }
8370
8371 mod ___detail {
8372 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
8373 where
8374 ___T: ::fidl_next::Transport,
8375 {
8376 type Client = CapabilityStoreClient<___T>;
8377 type Server = CapabilityStoreServer<___T>;
8378 }
8379
8380 #[repr(transparent)]
8382 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
8383 #[allow(dead_code)]
8384 client: ::fidl_next::protocol::Client<___T>,
8385 }
8386
8387 impl<___T> CapabilityStoreClient<___T>
8388 where
8389 ___T: ::fidl_next::Transport,
8390 {
8391 #[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"]
8392 pub fn duplicate(
8393 &self,
8394
8395 id: impl ::fidl_next::Encode<
8396 ::fidl_next::WireU64,
8397 <___T as ::fidl_next::Transport>::SendBuffer,
8398 >,
8399
8400 dest_id: impl ::fidl_next::Encode<
8401 ::fidl_next::WireU64,
8402 <___T as ::fidl_next::Transport>::SendBuffer,
8403 >,
8404 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
8405 where
8406 <___T as ::fidl_next::Transport>::SendBuffer:
8407 ::fidl_next::encoder::InternalHandleEncoder,
8408 {
8409 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
8410 }
8411
8412 #[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"]
8413 pub fn duplicate_with<___R>(
8414 &self,
8415 request: ___R,
8416 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
8417 where
8418 ___R: ::fidl_next::Encode<
8419 crate::wire::CapabilityStoreDuplicateRequest,
8420 <___T as ::fidl_next::Transport>::SendBuffer,
8421 >,
8422 {
8423 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8424 6727592627741008260,
8425 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
8426 request,
8427 ))
8428 }
8429
8430 #[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"]
8431 pub fn drop(
8432 &self,
8433
8434 id: impl ::fidl_next::Encode<
8435 ::fidl_next::WireU64,
8436 <___T as ::fidl_next::Transport>::SendBuffer,
8437 >,
8438 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
8439 where
8440 <___T as ::fidl_next::Transport>::SendBuffer:
8441 ::fidl_next::encoder::InternalHandleEncoder,
8442 {
8443 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
8444 }
8445
8446 #[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"]
8447 pub fn drop_with<___R>(
8448 &self,
8449 request: ___R,
8450 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
8451 where
8452 ___R: ::fidl_next::Encode<
8453 crate::wire::CapabilityStoreDropRequest,
8454 <___T as ::fidl_next::Transport>::SendBuffer,
8455 >,
8456 {
8457 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8458 753328233834620249,
8459 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
8460 request,
8461 ))
8462 }
8463
8464 #[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"]
8465 pub fn export(
8466 &self,
8467
8468 id: impl ::fidl_next::Encode<
8469 ::fidl_next::WireU64,
8470 <___T as ::fidl_next::Transport>::SendBuffer,
8471 >,
8472 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
8473 where
8474 <___T as ::fidl_next::Transport>::SendBuffer:
8475 ::fidl_next::encoder::InternalHandleEncoder,
8476 {
8477 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
8478 }
8479
8480 #[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"]
8481 pub fn export_with<___R>(
8482 &self,
8483 request: ___R,
8484 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
8485 where
8486 ___R: ::fidl_next::Encode<
8487 crate::wire::CapabilityStoreExportRequest,
8488 <___T as ::fidl_next::Transport>::SendBuffer,
8489 >,
8490 {
8491 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8492 226159162093533951,
8493 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
8494 request,
8495 ))
8496 }
8497
8498 #[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"]
8499 pub fn import(
8500 &self,
8501
8502 id: impl ::fidl_next::Encode<
8503 ::fidl_next::WireU64,
8504 <___T as ::fidl_next::Transport>::SendBuffer,
8505 >,
8506
8507 capability: impl ::fidl_next::Encode<
8508 crate::wire::Capability<'static>,
8509 <___T as ::fidl_next::Transport>::SendBuffer,
8510 >,
8511 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
8512 where
8513 <___T as ::fidl_next::Transport>::SendBuffer:
8514 ::fidl_next::encoder::InternalHandleEncoder,
8515 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8516 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8517 {
8518 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
8519 }
8520
8521 #[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"]
8522 pub fn import_with<___R>(
8523 &self,
8524 request: ___R,
8525 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
8526 where
8527 ___R: ::fidl_next::Encode<
8528 crate::wire::CapabilityStoreImportRequest<'static>,
8529 <___T as ::fidl_next::Transport>::SendBuffer,
8530 >,
8531 {
8532 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8533 2276030276116435867,
8534 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
8535 request,
8536 ))
8537 }
8538
8539 #[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"]
8540 pub fn connector_create(
8541 &self,
8542
8543 id: impl ::fidl_next::Encode<
8544 ::fidl_next::WireU64,
8545 <___T as ::fidl_next::Transport>::SendBuffer,
8546 >,
8547
8548 receiver: impl ::fidl_next::Encode<
8549 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
8550 <___T as ::fidl_next::Transport>::SendBuffer,
8551 >,
8552 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
8553 where
8554 <___T as ::fidl_next::Transport>::SendBuffer:
8555 ::fidl_next::encoder::InternalHandleEncoder,
8556 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8557 {
8558 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
8559 id,
8560
8561 receiver,
8562 })
8563 }
8564
8565 #[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"]
8566 pub fn connector_create_with<___R>(
8567 &self,
8568 request: ___R,
8569 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
8570 where
8571 ___R: ::fidl_next::Encode<
8572 crate::wire::CapabilityStoreConnectorCreateRequest,
8573 <___T as ::fidl_next::Transport>::SendBuffer,
8574 >,
8575 {
8576 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8577 2979461408102095909,
8578 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
8579 request,
8580 ))
8581 }
8582
8583 #[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"]
8584 pub fn connector_open(
8585 &self,
8586
8587 id: impl ::fidl_next::Encode<
8588 ::fidl_next::WireU64,
8589 <___T as ::fidl_next::Transport>::SendBuffer,
8590 >,
8591
8592 server_end: impl ::fidl_next::Encode<
8593 ::fidl_next::fuchsia::WireChannel,
8594 <___T as ::fidl_next::Transport>::SendBuffer,
8595 >,
8596 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
8597 where
8598 <___T as ::fidl_next::Transport>::SendBuffer:
8599 ::fidl_next::encoder::InternalHandleEncoder,
8600 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8601 {
8602 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
8603 id,
8604
8605 server_end,
8606 })
8607 }
8608
8609 #[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"]
8610 pub fn connector_open_with<___R>(
8611 &self,
8612 request: ___R,
8613 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
8614 where
8615 ___R: ::fidl_next::Encode<
8616 crate::wire::CapabilityStoreConnectorOpenRequest,
8617 <___T as ::fidl_next::Transport>::SendBuffer,
8618 >,
8619 {
8620 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8621 6016362336453278623,
8622 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
8623 request,
8624 ))
8625 }
8626
8627 #[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"]
8628 pub fn dir_connector_create(
8629 &self,
8630
8631 id: impl ::fidl_next::Encode<
8632 ::fidl_next::WireU64,
8633 <___T as ::fidl_next::Transport>::SendBuffer,
8634 >,
8635
8636 receiver: impl ::fidl_next::Encode<
8637 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
8638 <___T as ::fidl_next::Transport>::SendBuffer,
8639 >,
8640 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
8641 where
8642 <___T as ::fidl_next::Transport>::SendBuffer:
8643 ::fidl_next::encoder::InternalHandleEncoder,
8644 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8645 {
8646 self.dir_connector_create_with(
8647 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
8648 )
8649 }
8650
8651 #[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"]
8652 pub fn dir_connector_create_with<___R>(
8653 &self,
8654 request: ___R,
8655 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
8656 where
8657 ___R: ::fidl_next::Encode<
8658 crate::wire::CapabilityStoreDirConnectorCreateRequest,
8659 <___T as ::fidl_next::Transport>::SendBuffer,
8660 >,
8661 {
8662 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8663 1756747594275428795,
8664 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
8665 request,
8666 ))
8667 }
8668
8669 #[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"]
8670 pub fn dir_connector_open(
8671 &self,
8672
8673 id: impl ::fidl_next::Encode<
8674 ::fidl_next::WireU64,
8675 <___T as ::fidl_next::Transport>::SendBuffer,
8676 >,
8677
8678 server_end: impl ::fidl_next::Encode<
8679 ::fidl_next::ServerEnd<
8680 ::fidl_next_fuchsia_io::Directory,
8681 ::fidl_next::fuchsia::WireChannel,
8682 >,
8683 <___T as ::fidl_next::Transport>::SendBuffer,
8684 >,
8685 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
8686 where
8687 <___T as ::fidl_next::Transport>::SendBuffer:
8688 ::fidl_next::encoder::InternalHandleEncoder,
8689 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8690 {
8691 self.dir_connector_open_with(
8692 crate::generic::CapabilityStoreDirConnectorOpenRequest { id, server_end },
8693 )
8694 }
8695
8696 #[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"]
8697 pub fn dir_connector_open_with<___R>(
8698 &self,
8699 request: ___R,
8700 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
8701 where
8702 ___R: ::fidl_next::Encode<
8703 crate::wire::CapabilityStoreDirConnectorOpenRequest,
8704 <___T as ::fidl_next::Transport>::SendBuffer,
8705 >,
8706 {
8707 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8708 6219704004220369153,
8709 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
8710 request,
8711 ))
8712 }
8713
8714 #[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"]
8715 pub fn dictionary_create(
8716 &self,
8717
8718 id: impl ::fidl_next::Encode<
8719 ::fidl_next::WireU64,
8720 <___T as ::fidl_next::Transport>::SendBuffer,
8721 >,
8722 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
8723 where
8724 <___T as ::fidl_next::Transport>::SendBuffer:
8725 ::fidl_next::encoder::InternalHandleEncoder,
8726 {
8727 self.dictionary_create_with(
8728 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
8729 )
8730 }
8731
8732 #[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"]
8733 pub fn dictionary_create_with<___R>(
8734 &self,
8735 request: ___R,
8736 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
8737 where
8738 ___R: ::fidl_next::Encode<
8739 crate::wire::CapabilityStoreDictionaryCreateRequest,
8740 <___T as ::fidl_next::Transport>::SendBuffer,
8741 >,
8742 {
8743 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8744 7608770958894948499,
8745 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
8746 request,
8747 ))
8748 }
8749
8750 #[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"]
8751 pub fn dictionary_legacy_import(
8752 &self,
8753
8754 id: impl ::fidl_next::Encode<
8755 ::fidl_next::WireU64,
8756 <___T as ::fidl_next::Transport>::SendBuffer,
8757 >,
8758
8759 client_end: impl ::fidl_next::Encode<
8760 ::fidl_next::fuchsia::WireChannel,
8761 <___T as ::fidl_next::Transport>::SendBuffer,
8762 >,
8763 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
8764 where
8765 <___T as ::fidl_next::Transport>::SendBuffer:
8766 ::fidl_next::encoder::InternalHandleEncoder,
8767 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8768 {
8769 self.dictionary_legacy_import_with(
8770 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
8771 )
8772 }
8773
8774 #[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"]
8775 pub fn dictionary_legacy_import_with<___R>(
8776 &self,
8777 request: ___R,
8778 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
8779 where
8780 ___R: ::fidl_next::Encode<
8781 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
8782 <___T as ::fidl_next::Transport>::SendBuffer,
8783 >,
8784 {
8785 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8786 8285893703432012383,
8787 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
8788 request,
8789 ))
8790 }
8791
8792 #[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"]
8793 pub fn dictionary_legacy_export(
8794 &self,
8795
8796 id: impl ::fidl_next::Encode<
8797 ::fidl_next::WireU64,
8798 <___T as ::fidl_next::Transport>::SendBuffer,
8799 >,
8800
8801 server_end: impl ::fidl_next::Encode<
8802 ::fidl_next::fuchsia::WireChannel,
8803 <___T as ::fidl_next::Transport>::SendBuffer,
8804 >,
8805 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
8806 where
8807 <___T as ::fidl_next::Transport>::SendBuffer:
8808 ::fidl_next::encoder::InternalHandleEncoder,
8809 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8810 {
8811 self.dictionary_legacy_export_with(
8812 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
8813 )
8814 }
8815
8816 #[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"]
8817 pub fn dictionary_legacy_export_with<___R>(
8818 &self,
8819 request: ___R,
8820 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
8821 where
8822 ___R: ::fidl_next::Encode<
8823 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
8824 <___T as ::fidl_next::Transport>::SendBuffer,
8825 >,
8826 {
8827 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8828 4647175832683306445,
8829 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
8830 request,
8831 ))
8832 }
8833
8834 #[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"]
8835 pub fn dictionary_insert(
8836 &self,
8837
8838 id: impl ::fidl_next::Encode<
8839 ::fidl_next::WireU64,
8840 <___T as ::fidl_next::Transport>::SendBuffer,
8841 >,
8842
8843 item: impl ::fidl_next::Encode<
8844 crate::wire::DictionaryItem<'static>,
8845 <___T as ::fidl_next::Transport>::SendBuffer,
8846 >,
8847 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8848 where
8849 <___T as ::fidl_next::Transport>::SendBuffer:
8850 ::fidl_next::encoder::InternalHandleEncoder,
8851 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8852 {
8853 self.dictionary_insert_with(
8854 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
8855 )
8856 }
8857
8858 #[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"]
8859 pub fn dictionary_insert_with<___R>(
8860 &self,
8861 request: ___R,
8862 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8863 where
8864 ___R: ::fidl_next::Encode<
8865 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
8866 <___T as ::fidl_next::Transport>::SendBuffer,
8867 >,
8868 {
8869 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8870 8575443262986538023,
8871 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
8872 request,
8873 ))
8874 }
8875
8876 #[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"]
8877 pub fn dictionary_get(
8878 &self,
8879
8880 id: impl ::fidl_next::Encode<
8881 ::fidl_next::WireU64,
8882 <___T as ::fidl_next::Transport>::SendBuffer,
8883 >,
8884
8885 key: impl ::fidl_next::Encode<
8886 ::fidl_next::WireString<'static>,
8887 <___T as ::fidl_next::Transport>::SendBuffer,
8888 >,
8889
8890 dest_id: impl ::fidl_next::Encode<
8891 ::fidl_next::WireU64,
8892 <___T as ::fidl_next::Transport>::SendBuffer,
8893 >,
8894 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8895 where
8896 <___T as ::fidl_next::Transport>::SendBuffer:
8897 ::fidl_next::encoder::InternalHandleEncoder,
8898 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8899 {
8900 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
8901 id,
8902
8903 key,
8904
8905 dest_id,
8906 })
8907 }
8908
8909 #[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"]
8910 pub fn dictionary_get_with<___R>(
8911 &self,
8912 request: ___R,
8913 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8914 where
8915 ___R: ::fidl_next::Encode<
8916 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
8917 <___T as ::fidl_next::Transport>::SendBuffer,
8918 >,
8919 {
8920 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8921 5592951026866236882,
8922 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
8923 request,
8924 ))
8925 }
8926
8927 #[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"]
8928 pub fn dictionary_remove(
8929 &self,
8930
8931 id: impl ::fidl_next::Encode<
8932 ::fidl_next::WireU64,
8933 <___T as ::fidl_next::Transport>::SendBuffer,
8934 >,
8935
8936 key: impl ::fidl_next::Encode<
8937 ::fidl_next::WireString<'static>,
8938 <___T as ::fidl_next::Transport>::SendBuffer,
8939 >,
8940
8941 dest_id: impl ::fidl_next::Encode<
8942 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
8943 <___T as ::fidl_next::Transport>::SendBuffer,
8944 >,
8945 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8946 where
8947 <___T as ::fidl_next::Transport>::SendBuffer:
8948 ::fidl_next::encoder::InternalHandleEncoder,
8949 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8950 {
8951 self.dictionary_remove_with(
8952 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
8953 )
8954 }
8955
8956 #[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"]
8957 pub fn dictionary_remove_with<___R>(
8958 &self,
8959 request: ___R,
8960 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8961 where
8962 ___R: ::fidl_next::Encode<
8963 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
8964 <___T as ::fidl_next::Transport>::SendBuffer,
8965 >,
8966 {
8967 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8968 343892214579320051,
8969 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
8970 request,
8971 ))
8972 }
8973
8974 #[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"]
8975 pub fn dictionary_copy(
8976 &self,
8977
8978 id: impl ::fidl_next::Encode<
8979 ::fidl_next::WireU64,
8980 <___T as ::fidl_next::Transport>::SendBuffer,
8981 >,
8982
8983 dest_id: impl ::fidl_next::Encode<
8984 ::fidl_next::WireU64,
8985 <___T as ::fidl_next::Transport>::SendBuffer,
8986 >,
8987 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
8988 where
8989 <___T as ::fidl_next::Transport>::SendBuffer:
8990 ::fidl_next::encoder::InternalHandleEncoder,
8991 {
8992 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
8993 id,
8994
8995 dest_id,
8996 })
8997 }
8998
8999 #[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"]
9000 pub fn dictionary_copy_with<___R>(
9001 &self,
9002 request: ___R,
9003 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
9004 where
9005 ___R: ::fidl_next::Encode<
9006 crate::wire::CapabilityStoreDictionaryCopyRequest,
9007 <___T as ::fidl_next::Transport>::SendBuffer,
9008 >,
9009 {
9010 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9011 3977783339739362383,
9012 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
9013 request,
9014 ))
9015 }
9016
9017 #[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"]
9018 pub fn dictionary_keys(
9019 &self,
9020
9021 id: impl ::fidl_next::Encode<
9022 ::fidl_next::WireU64,
9023 <___T as ::fidl_next::Transport>::SendBuffer,
9024 >,
9025
9026 iterator: impl ::fidl_next::Encode<
9027 ::fidl_next::ServerEnd<
9028 crate::DictionaryKeysIterator,
9029 ::fidl_next::fuchsia::WireChannel,
9030 >,
9031 <___T as ::fidl_next::Transport>::SendBuffer,
9032 >,
9033 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9034 where
9035 <___T as ::fidl_next::Transport>::SendBuffer:
9036 ::fidl_next::encoder::InternalHandleEncoder,
9037 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9038 {
9039 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
9040 id,
9041
9042 iterator,
9043 })
9044 }
9045
9046 #[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"]
9047 pub fn dictionary_keys_with<___R>(
9048 &self,
9049 request: ___R,
9050 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9051 where
9052 ___R: ::fidl_next::Encode<
9053 crate::wire::CapabilityStoreDictionaryKeysRequest,
9054 <___T as ::fidl_next::Transport>::SendBuffer,
9055 >,
9056 {
9057 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9058 597577248872787102,
9059 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
9060 request,
9061 ))
9062 }
9063
9064 #[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"]
9065 pub fn dictionary_enumerate(
9066 &self,
9067
9068 id: impl ::fidl_next::Encode<
9069 ::fidl_next::WireU64,
9070 <___T as ::fidl_next::Transport>::SendBuffer,
9071 >,
9072
9073 iterator: impl ::fidl_next::Encode<
9074 ::fidl_next::ServerEnd<
9075 crate::DictionaryEnumerateIterator,
9076 ::fidl_next::fuchsia::WireChannel,
9077 >,
9078 <___T as ::fidl_next::Transport>::SendBuffer,
9079 >,
9080 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9081 where
9082 <___T as ::fidl_next::Transport>::SendBuffer:
9083 ::fidl_next::encoder::InternalHandleEncoder,
9084 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9085 {
9086 self.dictionary_enumerate_with(
9087 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
9088 )
9089 }
9090
9091 #[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"]
9092 pub fn dictionary_enumerate_with<___R>(
9093 &self,
9094 request: ___R,
9095 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9096 where
9097 ___R: ::fidl_next::Encode<
9098 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
9099 <___T as ::fidl_next::Transport>::SendBuffer,
9100 >,
9101 {
9102 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9103 964467096271472193,
9104 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
9105 request,
9106 ))
9107 }
9108
9109 #[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"]
9110 pub fn dictionary_drain(
9111 &self,
9112
9113 id: impl ::fidl_next::Encode<
9114 ::fidl_next::WireU64,
9115 <___T as ::fidl_next::Transport>::SendBuffer,
9116 >,
9117
9118 iterator: impl ::fidl_next::Encode<
9119 ::fidl_next::ServerEnd<
9120 crate::DictionaryDrainIterator,
9121 ::fidl_next::fuchsia::WireOptionalChannel,
9122 >,
9123 <___T as ::fidl_next::Transport>::SendBuffer,
9124 >,
9125 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
9126 where
9127 <___T as ::fidl_next::Transport>::SendBuffer:
9128 ::fidl_next::encoder::InternalHandleEncoder,
9129 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9130 {
9131 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
9132 id,
9133
9134 iterator,
9135 })
9136 }
9137
9138 #[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"]
9139 pub fn dictionary_drain_with<___R>(
9140 &self,
9141 request: ___R,
9142 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
9143 where
9144 ___R: ::fidl_next::Encode<
9145 crate::wire::CapabilityStoreDictionaryDrainRequest,
9146 <___T as ::fidl_next::Transport>::SendBuffer,
9147 >,
9148 {
9149 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9150 2928364469569621208,
9151 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
9152 request,
9153 ))
9154 }
9155 }
9156
9157 #[repr(transparent)]
9159 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
9160 server: ::fidl_next::protocol::Server<___T>,
9161 }
9162
9163 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
9164 }
9165}
9166
9167pub trait CapabilityStoreClientHandler<
9171 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9172 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9173>
9174{
9175 fn on_unknown_interaction(
9176 &mut self,
9177 ordinal: u64,
9178 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9179 ::core::future::ready(())
9180 }
9181}
9182
9183impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
9184where
9185 ___T: ::fidl_next::Transport,
9186{
9187 async fn on_unknown_interaction(&mut self, _: u64) {}
9188}
9189
9190impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
9191where
9192 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
9193 ___T: ::fidl_next::Transport,
9194{
9195 async fn on_event(
9196 handler: &mut ___H,
9197 ordinal: u64,
9198 flexibility: ::fidl_next::protocol::Flexibility,
9199 buffer: ___T::RecvBuffer,
9200 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9201 match ordinal {
9202 ordinal => {
9203 handler.on_unknown_interaction(ordinal).await;
9204 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9205 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9206 } else {
9207 Ok(())
9208 }
9209 }
9210 }
9211 }
9212}
9213
9214pub trait CapabilityStoreServerHandler<
9218 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9219 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9220>
9221{
9222 #[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"]
9223 fn duplicate(
9224 &mut self,
9225
9226 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
9227
9228 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
9229 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9230
9231 #[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"]
9232 fn drop(
9233 &mut self,
9234
9235 request: ::fidl_next::Request<capability_store::Drop, ___T>,
9236
9237 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
9238 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9239
9240 #[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"]
9241 fn export(
9242 &mut self,
9243
9244 request: ::fidl_next::Request<capability_store::Export, ___T>,
9245
9246 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
9247 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9248
9249 #[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"]
9250 fn import(
9251 &mut self,
9252
9253 request: ::fidl_next::Request<capability_store::Import, ___T>,
9254
9255 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
9256 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9257
9258 #[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"]
9259 fn connector_create(
9260 &mut self,
9261
9262 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
9263
9264 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
9265 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9266
9267 #[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"]
9268 fn connector_open(
9269 &mut self,
9270
9271 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
9272
9273 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
9274 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9275
9276 #[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"]
9277 fn dir_connector_create(
9278 &mut self,
9279
9280 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
9281
9282 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
9283 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9284
9285 #[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"]
9286 fn dir_connector_open(
9287 &mut self,
9288
9289 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
9290
9291 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
9292 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9293
9294 #[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"]
9295 fn dictionary_create(
9296 &mut self,
9297
9298 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
9299
9300 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
9301 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9302
9303 #[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"]
9304 fn dictionary_legacy_import(
9305 &mut self,
9306
9307 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
9308
9309 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
9310 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9311
9312 #[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"]
9313 fn dictionary_legacy_export(
9314 &mut self,
9315
9316 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
9317
9318 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
9319 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9320
9321 #[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"]
9322 fn dictionary_insert(
9323 &mut self,
9324
9325 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
9326
9327 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
9328 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9329
9330 #[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"]
9331 fn dictionary_get(
9332 &mut self,
9333
9334 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
9335
9336 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
9337 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9338
9339 #[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"]
9340 fn dictionary_remove(
9341 &mut self,
9342
9343 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
9344
9345 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
9346 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9347
9348 #[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"]
9349 fn dictionary_copy(
9350 &mut self,
9351
9352 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
9353
9354 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
9355 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9356
9357 #[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"]
9358 fn dictionary_keys(
9359 &mut self,
9360
9361 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
9362
9363 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
9364 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9365
9366 #[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"]
9367 fn dictionary_enumerate(
9368 &mut self,
9369
9370 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
9371
9372 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
9373 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9374
9375 #[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"]
9376 fn dictionary_drain(
9377 &mut self,
9378
9379 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
9380
9381 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
9382 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9383
9384 fn on_unknown_interaction(
9385 &mut self,
9386 ordinal: u64,
9387 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9388 ::core::future::ready(())
9389 }
9390}
9391
9392impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
9393where
9394 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
9395 ___T: ::fidl_next::Transport,
9396 <capability_store::Duplicate as ::fidl_next::Method>::Request:
9397 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9398 <capability_store::Drop as ::fidl_next::Method>::Request:
9399 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9400 <capability_store::Export as ::fidl_next::Method>::Request:
9401 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9402 <capability_store::Import as ::fidl_next::Method>::Request:
9403 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9404 <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
9405 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9406 <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
9407 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9408 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
9409 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9410 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
9411 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9412 <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
9413 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9414 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
9415 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9416 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
9417 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9418 <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
9419 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9420 <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
9421 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9422 <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
9423 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9424 <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
9425 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9426 <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
9427 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9428 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
9429 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9430 <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
9431 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9432{
9433 async fn on_one_way(
9434 handler: &mut ___H,
9435 ordinal: u64,
9436 flexibility: ::fidl_next::protocol::Flexibility,
9437 buffer: ___T::RecvBuffer,
9438 ) -> ::core::result::Result<
9439 (),
9440 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9441 > {
9442 match ordinal {
9443 ordinal => {
9444 handler.on_unknown_interaction(ordinal).await;
9445 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9446 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9447 } else {
9448 Ok(())
9449 }
9450 }
9451 }
9452 }
9453
9454 async fn on_two_way(
9455 handler: &mut ___H,
9456 ordinal: u64,
9457 flexibility: ::fidl_next::protocol::Flexibility,
9458 buffer: ___T::RecvBuffer,
9459 responder: ::fidl_next::protocol::Responder<___T>,
9460 ) -> ::core::result::Result<
9461 (),
9462 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9463 > {
9464 match ordinal {
9465 6727592627741008260 => {
9466 let responder = ::fidl_next::Responder::from_untyped(responder);
9467
9468 match ::fidl_next::DecoderExt::decode(buffer) {
9469 Ok(decoded) => {
9470 handler
9471 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
9472 .await;
9473 Ok(())
9474 }
9475 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9476 ordinal: 6727592627741008260,
9477 error,
9478 }),
9479 }
9480 }
9481
9482 753328233834620249 => {
9483 let responder = ::fidl_next::Responder::from_untyped(responder);
9484
9485 match ::fidl_next::DecoderExt::decode(buffer) {
9486 Ok(decoded) => {
9487 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
9488 Ok(())
9489 }
9490 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9491 ordinal: 753328233834620249,
9492 error,
9493 }),
9494 }
9495 }
9496
9497 226159162093533951 => {
9498 let responder = ::fidl_next::Responder::from_untyped(responder);
9499
9500 match ::fidl_next::DecoderExt::decode(buffer) {
9501 Ok(decoded) => {
9502 handler
9503 .export(::fidl_next::Request::from_decoded(decoded), responder)
9504 .await;
9505 Ok(())
9506 }
9507 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9508 ordinal: 226159162093533951,
9509 error,
9510 }),
9511 }
9512 }
9513
9514 2276030276116435867 => {
9515 let responder = ::fidl_next::Responder::from_untyped(responder);
9516
9517 match ::fidl_next::DecoderExt::decode(buffer) {
9518 Ok(decoded) => {
9519 handler
9520 .import(::fidl_next::Request::from_decoded(decoded), responder)
9521 .await;
9522 Ok(())
9523 }
9524 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9525 ordinal: 2276030276116435867,
9526 error,
9527 }),
9528 }
9529 }
9530
9531 2979461408102095909 => {
9532 let responder = ::fidl_next::Responder::from_untyped(responder);
9533
9534 match ::fidl_next::DecoderExt::decode(buffer) {
9535 Ok(decoded) => {
9536 handler
9537 .connector_create(
9538 ::fidl_next::Request::from_decoded(decoded),
9539 responder,
9540 )
9541 .await;
9542 Ok(())
9543 }
9544 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9545 ordinal: 2979461408102095909,
9546 error,
9547 }),
9548 }
9549 }
9550
9551 6016362336453278623 => {
9552 let responder = ::fidl_next::Responder::from_untyped(responder);
9553
9554 match ::fidl_next::DecoderExt::decode(buffer) {
9555 Ok(decoded) => {
9556 handler
9557 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
9558 .await;
9559 Ok(())
9560 }
9561 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9562 ordinal: 6016362336453278623,
9563 error,
9564 }),
9565 }
9566 }
9567
9568 1756747594275428795 => {
9569 let responder = ::fidl_next::Responder::from_untyped(responder);
9570
9571 match ::fidl_next::DecoderExt::decode(buffer) {
9572 Ok(decoded) => {
9573 handler
9574 .dir_connector_create(
9575 ::fidl_next::Request::from_decoded(decoded),
9576 responder,
9577 )
9578 .await;
9579 Ok(())
9580 }
9581 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9582 ordinal: 1756747594275428795,
9583 error,
9584 }),
9585 }
9586 }
9587
9588 6219704004220369153 => {
9589 let responder = ::fidl_next::Responder::from_untyped(responder);
9590
9591 match ::fidl_next::DecoderExt::decode(buffer) {
9592 Ok(decoded) => {
9593 handler
9594 .dir_connector_open(
9595 ::fidl_next::Request::from_decoded(decoded),
9596 responder,
9597 )
9598 .await;
9599 Ok(())
9600 }
9601 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9602 ordinal: 6219704004220369153,
9603 error,
9604 }),
9605 }
9606 }
9607
9608 7608770958894948499 => {
9609 let responder = ::fidl_next::Responder::from_untyped(responder);
9610
9611 match ::fidl_next::DecoderExt::decode(buffer) {
9612 Ok(decoded) => {
9613 handler
9614 .dictionary_create(
9615 ::fidl_next::Request::from_decoded(decoded),
9616 responder,
9617 )
9618 .await;
9619 Ok(())
9620 }
9621 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9622 ordinal: 7608770958894948499,
9623 error,
9624 }),
9625 }
9626 }
9627
9628 8285893703432012383 => {
9629 let responder = ::fidl_next::Responder::from_untyped(responder);
9630
9631 match ::fidl_next::DecoderExt::decode(buffer) {
9632 Ok(decoded) => {
9633 handler
9634 .dictionary_legacy_import(
9635 ::fidl_next::Request::from_decoded(decoded),
9636 responder,
9637 )
9638 .await;
9639 Ok(())
9640 }
9641 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9642 ordinal: 8285893703432012383,
9643 error,
9644 }),
9645 }
9646 }
9647
9648 4647175832683306445 => {
9649 let responder = ::fidl_next::Responder::from_untyped(responder);
9650
9651 match ::fidl_next::DecoderExt::decode(buffer) {
9652 Ok(decoded) => {
9653 handler
9654 .dictionary_legacy_export(
9655 ::fidl_next::Request::from_decoded(decoded),
9656 responder,
9657 )
9658 .await;
9659 Ok(())
9660 }
9661 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9662 ordinal: 4647175832683306445,
9663 error,
9664 }),
9665 }
9666 }
9667
9668 8575443262986538023 => {
9669 let responder = ::fidl_next::Responder::from_untyped(responder);
9670
9671 match ::fidl_next::DecoderExt::decode(buffer) {
9672 Ok(decoded) => {
9673 handler
9674 .dictionary_insert(
9675 ::fidl_next::Request::from_decoded(decoded),
9676 responder,
9677 )
9678 .await;
9679 Ok(())
9680 }
9681 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9682 ordinal: 8575443262986538023,
9683 error,
9684 }),
9685 }
9686 }
9687
9688 5592951026866236882 => {
9689 let responder = ::fidl_next::Responder::from_untyped(responder);
9690
9691 match ::fidl_next::DecoderExt::decode(buffer) {
9692 Ok(decoded) => {
9693 handler
9694 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
9695 .await;
9696 Ok(())
9697 }
9698 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9699 ordinal: 5592951026866236882,
9700 error,
9701 }),
9702 }
9703 }
9704
9705 343892214579320051 => {
9706 let responder = ::fidl_next::Responder::from_untyped(responder);
9707
9708 match ::fidl_next::DecoderExt::decode(buffer) {
9709 Ok(decoded) => {
9710 handler
9711 .dictionary_remove(
9712 ::fidl_next::Request::from_decoded(decoded),
9713 responder,
9714 )
9715 .await;
9716 Ok(())
9717 }
9718 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9719 ordinal: 343892214579320051,
9720 error,
9721 }),
9722 }
9723 }
9724
9725 3977783339739362383 => {
9726 let responder = ::fidl_next::Responder::from_untyped(responder);
9727
9728 match ::fidl_next::DecoderExt::decode(buffer) {
9729 Ok(decoded) => {
9730 handler
9731 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
9732 .await;
9733 Ok(())
9734 }
9735 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9736 ordinal: 3977783339739362383,
9737 error,
9738 }),
9739 }
9740 }
9741
9742 597577248872787102 => {
9743 let responder = ::fidl_next::Responder::from_untyped(responder);
9744
9745 match ::fidl_next::DecoderExt::decode(buffer) {
9746 Ok(decoded) => {
9747 handler
9748 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
9749 .await;
9750 Ok(())
9751 }
9752 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9753 ordinal: 597577248872787102,
9754 error,
9755 }),
9756 }
9757 }
9758
9759 964467096271472193 => {
9760 let responder = ::fidl_next::Responder::from_untyped(responder);
9761
9762 match ::fidl_next::DecoderExt::decode(buffer) {
9763 Ok(decoded) => {
9764 handler
9765 .dictionary_enumerate(
9766 ::fidl_next::Request::from_decoded(decoded),
9767 responder,
9768 )
9769 .await;
9770 Ok(())
9771 }
9772 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9773 ordinal: 964467096271472193,
9774 error,
9775 }),
9776 }
9777 }
9778
9779 2928364469569621208 => {
9780 let responder = ::fidl_next::Responder::from_untyped(responder);
9781
9782 match ::fidl_next::DecoderExt::decode(buffer) {
9783 Ok(decoded) => {
9784 handler
9785 .dictionary_drain(
9786 ::fidl_next::Request::from_decoded(decoded),
9787 responder,
9788 )
9789 .await;
9790 Ok(())
9791 }
9792 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9793 ordinal: 2928364469569621208,
9794 error,
9795 }),
9796 }
9797 }
9798
9799 ordinal => {
9800 handler.on_unknown_interaction(ordinal).await;
9801 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9802 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9803 } else {
9804 responder
9805 .respond(
9806 ordinal,
9807 flexibility,
9808 ::fidl_next::Flexible::<()>::FrameworkErr(
9809 ::fidl_next::FrameworkError::UnknownMethod,
9810 ),
9811 )
9812 .expect("encoding a framework error should never fail")
9813 .await?;
9814 Ok(())
9815 }
9816 }
9817 }
9818 }
9819}
9820
9821#[derive(PartialEq, Debug)]
9823pub struct ConnectorRouter;
9824
9825impl ::fidl_next::Discoverable for ConnectorRouter {
9826 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
9827}
9828
9829#[cfg(target_os = "fuchsia")]
9830impl ::fidl_next::HasTransport for ConnectorRouter {
9831 type Transport = ::fidl_next::fuchsia::zx::Channel;
9832}
9833
9834pub mod connector_router {
9835 pub mod prelude {
9836 pub use crate::{
9837 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
9838 connector_router,
9839 };
9840
9841 pub use crate::natural::ConnectorRouterRouteResponse;
9842
9843 pub use crate::natural::RouteRequest;
9844
9845 pub use crate::natural::RouterError;
9846 }
9847
9848 pub struct Route;
9849
9850 impl ::fidl_next::Method for Route {
9851 const ORDINAL: u64 = 8420527046218942310;
9852 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9853 ::fidl_next::protocol::Flexibility::Flexible;
9854
9855 type Protocol = crate::ConnectorRouter;
9856
9857 type Request = crate::wire::RouteRequest<'static>;
9858 }
9859
9860 impl ::fidl_next::TwoWayMethod for Route {
9861 type Response = ::fidl_next::WireFlexibleResult<
9862 'static,
9863 crate::wire::ConnectorRouterRouteResponse,
9864 crate::wire::RouterError,
9865 >;
9866 }
9867
9868 impl<___R> ::fidl_next::Respond<___R> for Route {
9869 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9870
9871 fn respond(response: ___R) -> Self::Output {
9872 ::fidl_next::FlexibleResult::Ok(response)
9873 }
9874 }
9875
9876 impl<___R> ::fidl_next::RespondErr<___R> for Route {
9877 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9878
9879 fn respond_err(response: ___R) -> Self::Output {
9880 ::fidl_next::FlexibleResult::Err(response)
9881 }
9882 }
9883
9884 mod ___detail {
9885 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
9886 where
9887 ___T: ::fidl_next::Transport,
9888 {
9889 type Client = ConnectorRouterClient<___T>;
9890 type Server = ConnectorRouterServer<___T>;
9891 }
9892
9893 #[repr(transparent)]
9895 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
9896 #[allow(dead_code)]
9897 client: ::fidl_next::protocol::Client<___T>,
9898 }
9899
9900 impl<___T> ConnectorRouterClient<___T>
9901 where
9902 ___T: ::fidl_next::Transport,
9903 {
9904 pub fn route_with<___R>(
9905 &self,
9906 request: ___R,
9907 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
9908 where
9909 ___R: ::fidl_next::Encode<
9910 crate::wire::RouteRequest<'static>,
9911 <___T as ::fidl_next::Transport>::SendBuffer,
9912 >,
9913 {
9914 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9915 8420527046218942310,
9916 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
9917 request,
9918 ))
9919 }
9920 }
9921
9922 #[repr(transparent)]
9924 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
9925 server: ::fidl_next::protocol::Server<___T>,
9926 }
9927
9928 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
9929 }
9930}
9931
9932pub trait ConnectorRouterClientHandler<
9936 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9937 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9938>
9939{
9940 fn on_unknown_interaction(
9941 &mut self,
9942 ordinal: u64,
9943 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9944 ::core::future::ready(())
9945 }
9946}
9947
9948impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
9949where
9950 ___T: ::fidl_next::Transport,
9951{
9952 async fn on_unknown_interaction(&mut self, _: u64) {}
9953}
9954
9955impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
9956where
9957 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
9958 ___T: ::fidl_next::Transport,
9959{
9960 async fn on_event(
9961 handler: &mut ___H,
9962 ordinal: u64,
9963 flexibility: ::fidl_next::protocol::Flexibility,
9964 buffer: ___T::RecvBuffer,
9965 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9966 match ordinal {
9967 ordinal => {
9968 handler.on_unknown_interaction(ordinal).await;
9969 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9970 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9971 } else {
9972 Ok(())
9973 }
9974 }
9975 }
9976 }
9977}
9978
9979pub trait ConnectorRouterServerHandler<
9983 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9984 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9985>
9986{
9987 fn route(
9988 &mut self,
9989
9990 request: ::fidl_next::Request<connector_router::Route, ___T>,
9991
9992 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
9993 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9994
9995 fn on_unknown_interaction(
9996 &mut self,
9997 ordinal: u64,
9998 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9999 ::core::future::ready(())
10000 }
10001}
10002
10003impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
10004where
10005 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
10006 ___T: ::fidl_next::Transport,
10007 <connector_router::Route as ::fidl_next::Method>::Request:
10008 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10009{
10010 async fn on_one_way(
10011 handler: &mut ___H,
10012 ordinal: u64,
10013 flexibility: ::fidl_next::protocol::Flexibility,
10014 buffer: ___T::RecvBuffer,
10015 ) -> ::core::result::Result<
10016 (),
10017 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10018 > {
10019 match ordinal {
10020 ordinal => {
10021 handler.on_unknown_interaction(ordinal).await;
10022 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10023 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10024 } else {
10025 Ok(())
10026 }
10027 }
10028 }
10029 }
10030
10031 async fn on_two_way(
10032 handler: &mut ___H,
10033 ordinal: u64,
10034 flexibility: ::fidl_next::protocol::Flexibility,
10035 buffer: ___T::RecvBuffer,
10036 responder: ::fidl_next::protocol::Responder<___T>,
10037 ) -> ::core::result::Result<
10038 (),
10039 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10040 > {
10041 match ordinal {
10042 8420527046218942310 => {
10043 let responder = ::fidl_next::Responder::from_untyped(responder);
10044
10045 match ::fidl_next::DecoderExt::decode(buffer) {
10046 Ok(decoded) => {
10047 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
10048 Ok(())
10049 }
10050 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10051 ordinal: 8420527046218942310,
10052 error,
10053 }),
10054 }
10055 }
10056
10057 ordinal => {
10058 handler.on_unknown_interaction(ordinal).await;
10059 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10060 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10061 } else {
10062 responder
10063 .respond(
10064 ordinal,
10065 flexibility,
10066 ::fidl_next::Flexible::<()>::FrameworkErr(
10067 ::fidl_next::FrameworkError::UnknownMethod,
10068 ),
10069 )
10070 .expect("encoding a framework error should never fail")
10071 .await?;
10072 Ok(())
10073 }
10074 }
10075 }
10076 }
10077}
10078
10079#[derive(PartialEq, Debug)]
10081pub struct DataRouter;
10082
10083impl ::fidl_next::Discoverable for DataRouter {
10084 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
10085}
10086
10087#[cfg(target_os = "fuchsia")]
10088impl ::fidl_next::HasTransport for DataRouter {
10089 type Transport = ::fidl_next::fuchsia::zx::Channel;
10090}
10091
10092pub mod data_router {
10093 pub mod prelude {
10094 pub use crate::{
10095 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
10096 };
10097
10098 pub use crate::natural::DataRouterRouteResponse;
10099
10100 pub use crate::natural::RouteRequest;
10101
10102 pub use crate::natural::RouterError;
10103 }
10104
10105 pub struct Route;
10106
10107 impl ::fidl_next::Method for Route {
10108 const ORDINAL: u64 = 3352890635970754564;
10109 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10110 ::fidl_next::protocol::Flexibility::Flexible;
10111
10112 type Protocol = crate::DataRouter;
10113
10114 type Request = crate::wire::RouteRequest<'static>;
10115 }
10116
10117 impl ::fidl_next::TwoWayMethod for Route {
10118 type Response = ::fidl_next::WireFlexibleResult<
10119 'static,
10120 crate::wire::DataRouterRouteResponse<'static>,
10121 crate::wire::RouterError,
10122 >;
10123 }
10124
10125 impl<___R> ::fidl_next::Respond<___R> for Route {
10126 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10127
10128 fn respond(response: ___R) -> Self::Output {
10129 ::fidl_next::FlexibleResult::Ok(response)
10130 }
10131 }
10132
10133 impl<___R> ::fidl_next::RespondErr<___R> for Route {
10134 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10135
10136 fn respond_err(response: ___R) -> Self::Output {
10137 ::fidl_next::FlexibleResult::Err(response)
10138 }
10139 }
10140
10141 mod ___detail {
10142 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
10143 where
10144 ___T: ::fidl_next::Transport,
10145 {
10146 type Client = DataRouterClient<___T>;
10147 type Server = DataRouterServer<___T>;
10148 }
10149
10150 #[repr(transparent)]
10152 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
10153 #[allow(dead_code)]
10154 client: ::fidl_next::protocol::Client<___T>,
10155 }
10156
10157 impl<___T> DataRouterClient<___T>
10158 where
10159 ___T: ::fidl_next::Transport,
10160 {
10161 pub fn route_with<___R>(
10162 &self,
10163 request: ___R,
10164 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10165 where
10166 ___R: ::fidl_next::Encode<
10167 crate::wire::RouteRequest<'static>,
10168 <___T as ::fidl_next::Transport>::SendBuffer,
10169 >,
10170 {
10171 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10172 3352890635970754564,
10173 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
10174 request,
10175 ))
10176 }
10177 }
10178
10179 #[repr(transparent)]
10181 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
10182 server: ::fidl_next::protocol::Server<___T>,
10183 }
10184
10185 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
10186 }
10187}
10188
10189pub trait DataRouterClientHandler<
10193 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10194 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10195>
10196{
10197 fn on_unknown_interaction(
10198 &mut self,
10199 ordinal: u64,
10200 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10201 ::core::future::ready(())
10202 }
10203}
10204
10205impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
10206where
10207 ___T: ::fidl_next::Transport,
10208{
10209 async fn on_unknown_interaction(&mut self, _: u64) {}
10210}
10211
10212impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
10213where
10214 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
10215 ___T: ::fidl_next::Transport,
10216{
10217 async fn on_event(
10218 handler: &mut ___H,
10219 ordinal: u64,
10220 flexibility: ::fidl_next::protocol::Flexibility,
10221 buffer: ___T::RecvBuffer,
10222 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10223 match ordinal {
10224 ordinal => {
10225 handler.on_unknown_interaction(ordinal).await;
10226 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10227 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10228 } else {
10229 Ok(())
10230 }
10231 }
10232 }
10233 }
10234}
10235
10236pub trait DataRouterServerHandler<
10240 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10241 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10242>
10243{
10244 fn route(
10245 &mut self,
10246
10247 request: ::fidl_next::Request<data_router::Route, ___T>,
10248
10249 responder: ::fidl_next::Responder<data_router::Route, ___T>,
10250 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10251
10252 fn on_unknown_interaction(
10253 &mut self,
10254 ordinal: u64,
10255 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10256 ::core::future::ready(())
10257 }
10258}
10259
10260impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
10261where
10262 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
10263 ___T: ::fidl_next::Transport,
10264 <data_router::Route as ::fidl_next::Method>::Request:
10265 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10266{
10267 async fn on_one_way(
10268 handler: &mut ___H,
10269 ordinal: u64,
10270 flexibility: ::fidl_next::protocol::Flexibility,
10271 buffer: ___T::RecvBuffer,
10272 ) -> ::core::result::Result<
10273 (),
10274 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10275 > {
10276 match ordinal {
10277 ordinal => {
10278 handler.on_unknown_interaction(ordinal).await;
10279 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10280 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10281 } else {
10282 Ok(())
10283 }
10284 }
10285 }
10286 }
10287
10288 async fn on_two_way(
10289 handler: &mut ___H,
10290 ordinal: u64,
10291 flexibility: ::fidl_next::protocol::Flexibility,
10292 buffer: ___T::RecvBuffer,
10293 responder: ::fidl_next::protocol::Responder<___T>,
10294 ) -> ::core::result::Result<
10295 (),
10296 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10297 > {
10298 match ordinal {
10299 3352890635970754564 => {
10300 let responder = ::fidl_next::Responder::from_untyped(responder);
10301
10302 match ::fidl_next::DecoderExt::decode(buffer) {
10303 Ok(decoded) => {
10304 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
10305 Ok(())
10306 }
10307 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10308 ordinal: 3352890635970754564,
10309 error,
10310 }),
10311 }
10312 }
10313
10314 ordinal => {
10315 handler.on_unknown_interaction(ordinal).await;
10316 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10317 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10318 } else {
10319 responder
10320 .respond(
10321 ordinal,
10322 flexibility,
10323 ::fidl_next::Flexible::<()>::FrameworkErr(
10324 ::fidl_next::FrameworkError::UnknownMethod,
10325 ),
10326 )
10327 .expect("encoding a framework error should never fail")
10328 .await?;
10329 Ok(())
10330 }
10331 }
10332 }
10333 }
10334}
10335
10336#[derive(PartialEq, Debug)]
10338pub struct DictionaryDrainIterator;
10339
10340#[cfg(target_os = "fuchsia")]
10341impl ::fidl_next::HasTransport for DictionaryDrainIterator {
10342 type Transport = ::fidl_next::fuchsia::zx::Channel;
10343}
10344
10345pub mod dictionary_drain_iterator {
10346 pub mod prelude {
10347 pub use crate::{
10348 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
10349 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
10350 };
10351
10352 pub use crate::natural::CapabilityStoreError;
10353
10354 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
10355
10356 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
10357 }
10358
10359 pub struct GetNext;
10360
10361 impl ::fidl_next::Method for GetNext {
10362 const ORDINAL: u64 = 5728722530628427873;
10363 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10364 ::fidl_next::protocol::Flexibility::Flexible;
10365
10366 type Protocol = crate::DictionaryDrainIterator;
10367
10368 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
10369 }
10370
10371 impl ::fidl_next::TwoWayMethod for GetNext {
10372 type Response = ::fidl_next::WireFlexibleResult<
10373 'static,
10374 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
10375 crate::wire::CapabilityStoreError,
10376 >;
10377 }
10378
10379 impl<___R> ::fidl_next::Respond<___R> for GetNext {
10380 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10381
10382 fn respond(response: ___R) -> Self::Output {
10383 ::fidl_next::FlexibleResult::Ok(response)
10384 }
10385 }
10386
10387 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
10388 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10389
10390 fn respond_err(response: ___R) -> Self::Output {
10391 ::fidl_next::FlexibleResult::Err(response)
10392 }
10393 }
10394
10395 mod ___detail {
10396 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
10397 where
10398 ___T: ::fidl_next::Transport,
10399 {
10400 type Client = DictionaryDrainIteratorClient<___T>;
10401 type Server = DictionaryDrainIteratorServer<___T>;
10402 }
10403
10404 #[repr(transparent)]
10406 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
10407 #[allow(dead_code)]
10408 client: ::fidl_next::protocol::Client<___T>,
10409 }
10410
10411 impl<___T> DictionaryDrainIteratorClient<___T>
10412 where
10413 ___T: ::fidl_next::Transport,
10414 {
10415 #[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"]
10416 pub fn get_next(
10417 &self,
10418
10419 start_id: impl ::fidl_next::Encode<
10420 ::fidl_next::WireU64,
10421 <___T as ::fidl_next::Transport>::SendBuffer,
10422 >,
10423
10424 limit: impl ::fidl_next::Encode<
10425 ::fidl_next::WireU32,
10426 <___T as ::fidl_next::Transport>::SendBuffer,
10427 >,
10428 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10429 where
10430 <___T as ::fidl_next::Transport>::SendBuffer:
10431 ::fidl_next::encoder::InternalHandleEncoder,
10432 {
10433 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
10434 start_id,
10435
10436 limit,
10437 })
10438 }
10439
10440 #[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"]
10441 pub fn get_next_with<___R>(
10442 &self,
10443 request: ___R,
10444 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10445 where
10446 ___R: ::fidl_next::Encode<
10447 crate::wire::DictionaryDrainIteratorGetNextRequest,
10448 <___T as ::fidl_next::Transport>::SendBuffer,
10449 >,
10450 {
10451 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10452 5728722530628427873,
10453 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
10454 request,
10455 ))
10456 }
10457 }
10458
10459 #[repr(transparent)]
10461 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
10462 server: ::fidl_next::protocol::Server<___T>,
10463 }
10464
10465 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
10466 }
10467}
10468
10469pub trait DictionaryDrainIteratorClientHandler<
10473 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10474 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10475>
10476{
10477 fn on_unknown_interaction(
10478 &mut self,
10479 ordinal: u64,
10480 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10481 ::core::future::ready(())
10482 }
10483}
10484
10485impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
10486where
10487 ___T: ::fidl_next::Transport,
10488{
10489 async fn on_unknown_interaction(&mut self, _: u64) {}
10490}
10491
10492impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
10493where
10494 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
10495 ___T: ::fidl_next::Transport,
10496{
10497 async fn on_event(
10498 handler: &mut ___H,
10499 ordinal: u64,
10500 flexibility: ::fidl_next::protocol::Flexibility,
10501 buffer: ___T::RecvBuffer,
10502 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10503 match ordinal {
10504 ordinal => {
10505 handler.on_unknown_interaction(ordinal).await;
10506 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10507 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10508 } else {
10509 Ok(())
10510 }
10511 }
10512 }
10513 }
10514}
10515
10516pub trait DictionaryDrainIteratorServerHandler<
10520 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10521 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10522>
10523{
10524 #[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"]
10525 fn get_next(
10526 &mut self,
10527
10528 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
10529
10530 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
10531 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10532
10533 fn on_unknown_interaction(
10534 &mut self,
10535 ordinal: u64,
10536 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10537 ::core::future::ready(())
10538 }
10539}
10540
10541impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
10542where
10543 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
10544 ___T: ::fidl_next::Transport,
10545 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
10546 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10547{
10548 async fn on_one_way(
10549 handler: &mut ___H,
10550 ordinal: u64,
10551 flexibility: ::fidl_next::protocol::Flexibility,
10552 buffer: ___T::RecvBuffer,
10553 ) -> ::core::result::Result<
10554 (),
10555 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10556 > {
10557 match ordinal {
10558 ordinal => {
10559 handler.on_unknown_interaction(ordinal).await;
10560 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10561 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10562 } else {
10563 Ok(())
10564 }
10565 }
10566 }
10567 }
10568
10569 async fn on_two_way(
10570 handler: &mut ___H,
10571 ordinal: u64,
10572 flexibility: ::fidl_next::protocol::Flexibility,
10573 buffer: ___T::RecvBuffer,
10574 responder: ::fidl_next::protocol::Responder<___T>,
10575 ) -> ::core::result::Result<
10576 (),
10577 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10578 > {
10579 match ordinal {
10580 5728722530628427873 => {
10581 let responder = ::fidl_next::Responder::from_untyped(responder);
10582
10583 match ::fidl_next::DecoderExt::decode(buffer) {
10584 Ok(decoded) => {
10585 handler
10586 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
10587 .await;
10588 Ok(())
10589 }
10590 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10591 ordinal: 5728722530628427873,
10592 error,
10593 }),
10594 }
10595 }
10596
10597 ordinal => {
10598 handler.on_unknown_interaction(ordinal).await;
10599 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10600 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10601 } else {
10602 responder
10603 .respond(
10604 ordinal,
10605 flexibility,
10606 ::fidl_next::Flexible::<()>::FrameworkErr(
10607 ::fidl_next::FrameworkError::UnknownMethod,
10608 ),
10609 )
10610 .expect("encoding a framework error should never fail")
10611 .await?;
10612 Ok(())
10613 }
10614 }
10615 }
10616 }
10617}
10618
10619#[derive(PartialEq, Debug)]
10621pub struct DictionaryEnumerateIterator;
10622
10623#[cfg(target_os = "fuchsia")]
10624impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
10625 type Transport = ::fidl_next::fuchsia::zx::Channel;
10626}
10627
10628pub mod dictionary_enumerate_iterator {
10629 pub mod prelude {
10630 pub use crate::{
10631 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
10632 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
10633 };
10634
10635 pub use crate::natural::CapabilityStoreError;
10636
10637 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
10638
10639 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
10640 }
10641
10642 pub struct GetNext;
10643
10644 impl ::fidl_next::Method for GetNext {
10645 const ORDINAL: u64 = 1511164556663256527;
10646 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10647 ::fidl_next::protocol::Flexibility::Flexible;
10648
10649 type Protocol = crate::DictionaryEnumerateIterator;
10650
10651 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
10652 }
10653
10654 impl ::fidl_next::TwoWayMethod for GetNext {
10655 type Response = ::fidl_next::WireFlexibleResult<
10656 'static,
10657 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
10658 crate::wire::CapabilityStoreError,
10659 >;
10660 }
10661
10662 impl<___R> ::fidl_next::Respond<___R> for GetNext {
10663 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10664
10665 fn respond(response: ___R) -> Self::Output {
10666 ::fidl_next::FlexibleResult::Ok(response)
10667 }
10668 }
10669
10670 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
10671 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10672
10673 fn respond_err(response: ___R) -> Self::Output {
10674 ::fidl_next::FlexibleResult::Err(response)
10675 }
10676 }
10677
10678 mod ___detail {
10679 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
10680 where
10681 ___T: ::fidl_next::Transport,
10682 {
10683 type Client = DictionaryEnumerateIteratorClient<___T>;
10684 type Server = DictionaryEnumerateIteratorServer<___T>;
10685 }
10686
10687 #[repr(transparent)]
10689 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
10690 #[allow(dead_code)]
10691 client: ::fidl_next::protocol::Client<___T>,
10692 }
10693
10694 impl<___T> DictionaryEnumerateIteratorClient<___T>
10695 where
10696 ___T: ::fidl_next::Transport,
10697 {
10698 #[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"]
10699 pub fn get_next(
10700 &self,
10701
10702 start_id: impl ::fidl_next::Encode<
10703 ::fidl_next::WireU64,
10704 <___T as ::fidl_next::Transport>::SendBuffer,
10705 >,
10706
10707 limit: impl ::fidl_next::Encode<
10708 ::fidl_next::WireU32,
10709 <___T as ::fidl_next::Transport>::SendBuffer,
10710 >,
10711 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10712 where
10713 <___T as ::fidl_next::Transport>::SendBuffer:
10714 ::fidl_next::encoder::InternalHandleEncoder,
10715 {
10716 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
10717 start_id,
10718
10719 limit,
10720 })
10721 }
10722
10723 #[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"]
10724 pub fn get_next_with<___R>(
10725 &self,
10726 request: ___R,
10727 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10728 where
10729 ___R: ::fidl_next::Encode<
10730 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
10731 <___T as ::fidl_next::Transport>::SendBuffer,
10732 >,
10733 {
10734 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10735 1511164556663256527,
10736 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
10737 request,
10738 ))
10739 }
10740 }
10741
10742 #[repr(transparent)]
10744 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
10745 server: ::fidl_next::protocol::Server<___T>,
10746 }
10747
10748 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
10749 }
10750}
10751
10752pub trait DictionaryEnumerateIteratorClientHandler<
10756 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10757 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10758>
10759{
10760 fn on_unknown_interaction(
10761 &mut self,
10762 ordinal: u64,
10763 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10764 ::core::future::ready(())
10765 }
10766}
10767
10768impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
10769where
10770 ___T: ::fidl_next::Transport,
10771{
10772 async fn on_unknown_interaction(&mut self, _: u64) {}
10773}
10774
10775impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
10776where
10777 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
10778 ___T: ::fidl_next::Transport,
10779{
10780 async fn on_event(
10781 handler: &mut ___H,
10782 ordinal: u64,
10783 flexibility: ::fidl_next::protocol::Flexibility,
10784 buffer: ___T::RecvBuffer,
10785 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10786 match ordinal {
10787 ordinal => {
10788 handler.on_unknown_interaction(ordinal).await;
10789 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10790 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10791 } else {
10792 Ok(())
10793 }
10794 }
10795 }
10796 }
10797}
10798
10799pub trait DictionaryEnumerateIteratorServerHandler<
10803 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10804 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10805>
10806{
10807 #[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"]
10808 fn get_next(
10809 &mut self,
10810
10811 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
10812
10813 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
10814 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10815
10816 fn on_unknown_interaction(
10817 &mut self,
10818 ordinal: u64,
10819 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10820 ::core::future::ready(())
10821 }
10822}
10823
10824impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
10825where
10826 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
10827 ___T: ::fidl_next::Transport,
10828 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
10829 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10830{
10831 async fn on_one_way(
10832 handler: &mut ___H,
10833 ordinal: u64,
10834 flexibility: ::fidl_next::protocol::Flexibility,
10835 buffer: ___T::RecvBuffer,
10836 ) -> ::core::result::Result<
10837 (),
10838 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10839 > {
10840 match ordinal {
10841 ordinal => {
10842 handler.on_unknown_interaction(ordinal).await;
10843 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10844 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10845 } else {
10846 Ok(())
10847 }
10848 }
10849 }
10850 }
10851
10852 async fn on_two_way(
10853 handler: &mut ___H,
10854 ordinal: u64,
10855 flexibility: ::fidl_next::protocol::Flexibility,
10856 buffer: ___T::RecvBuffer,
10857 responder: ::fidl_next::protocol::Responder<___T>,
10858 ) -> ::core::result::Result<
10859 (),
10860 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10861 > {
10862 match ordinal {
10863 1511164556663256527 => {
10864 let responder = ::fidl_next::Responder::from_untyped(responder);
10865
10866 match ::fidl_next::DecoderExt::decode(buffer) {
10867 Ok(decoded) => {
10868 handler
10869 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
10870 .await;
10871 Ok(())
10872 }
10873 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10874 ordinal: 1511164556663256527,
10875 error,
10876 }),
10877 }
10878 }
10879
10880 ordinal => {
10881 handler.on_unknown_interaction(ordinal).await;
10882 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10883 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10884 } else {
10885 responder
10886 .respond(
10887 ordinal,
10888 flexibility,
10889 ::fidl_next::Flexible::<()>::FrameworkErr(
10890 ::fidl_next::FrameworkError::UnknownMethod,
10891 ),
10892 )
10893 .expect("encoding a framework error should never fail")
10894 .await?;
10895 Ok(())
10896 }
10897 }
10898 }
10899 }
10900}
10901
10902#[derive(PartialEq, Debug)]
10904pub struct DictionaryKeysIterator;
10905
10906#[cfg(target_os = "fuchsia")]
10907impl ::fidl_next::HasTransport for DictionaryKeysIterator {
10908 type Transport = ::fidl_next::fuchsia::zx::Channel;
10909}
10910
10911pub mod dictionary_keys_iterator {
10912 pub mod prelude {
10913 pub use crate::{
10914 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
10915 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
10916 };
10917
10918 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
10919 }
10920
10921 pub struct GetNext;
10922
10923 impl ::fidl_next::Method for GetNext {
10924 const ORDINAL: u64 = 4987781442555247955;
10925 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10926 ::fidl_next::protocol::Flexibility::Flexible;
10927
10928 type Protocol = crate::DictionaryKeysIterator;
10929
10930 type Request = ();
10931 }
10932
10933 impl ::fidl_next::TwoWayMethod for GetNext {
10934 type Response = ::fidl_next::WireFlexible<
10935 'static,
10936 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
10937 >;
10938 }
10939
10940 impl<___R> ::fidl_next::Respond<___R> for GetNext {
10941 type Output =
10942 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
10943
10944 fn respond(response: ___R) -> Self::Output {
10945 ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
10946 keys: response,
10947 })
10948 }
10949 }
10950
10951 mod ___detail {
10952 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
10953 where
10954 ___T: ::fidl_next::Transport,
10955 {
10956 type Client = DictionaryKeysIteratorClient<___T>;
10957 type Server = DictionaryKeysIteratorServer<___T>;
10958 }
10959
10960 #[repr(transparent)]
10962 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
10963 #[allow(dead_code)]
10964 client: ::fidl_next::protocol::Client<___T>,
10965 }
10966
10967 impl<___T> DictionaryKeysIteratorClient<___T>
10968 where
10969 ___T: ::fidl_next::Transport,
10970 {
10971 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
10972 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10973 4987781442555247955,
10974 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
10975 (),
10976 ))
10977 }
10978 }
10979
10980 #[repr(transparent)]
10982 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
10983 server: ::fidl_next::protocol::Server<___T>,
10984 }
10985
10986 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
10987 }
10988}
10989
10990pub trait DictionaryKeysIteratorClientHandler<
10994 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10995 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10996>
10997{
10998 fn on_unknown_interaction(
10999 &mut self,
11000 ordinal: u64,
11001 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11002 ::core::future::ready(())
11003 }
11004}
11005
11006impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11007where
11008 ___T: ::fidl_next::Transport,
11009{
11010 async fn on_unknown_interaction(&mut self, _: u64) {}
11011}
11012
11013impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
11014where
11015 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
11016 ___T: ::fidl_next::Transport,
11017{
11018 async fn on_event(
11019 handler: &mut ___H,
11020 ordinal: u64,
11021 flexibility: ::fidl_next::protocol::Flexibility,
11022 buffer: ___T::RecvBuffer,
11023 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11024 match ordinal {
11025 ordinal => {
11026 handler.on_unknown_interaction(ordinal).await;
11027 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11028 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11029 } else {
11030 Ok(())
11031 }
11032 }
11033 }
11034 }
11035}
11036
11037pub trait DictionaryKeysIteratorServerHandler<
11041 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11042 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11043>
11044{
11045 fn get_next(
11046 &mut self,
11047
11048 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
11049 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11050
11051 fn on_unknown_interaction(
11052 &mut self,
11053 ordinal: u64,
11054 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11055 ::core::future::ready(())
11056 }
11057}
11058
11059impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
11060where
11061 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
11062 ___T: ::fidl_next::Transport,
11063{
11064 async fn on_one_way(
11065 handler: &mut ___H,
11066 ordinal: u64,
11067 flexibility: ::fidl_next::protocol::Flexibility,
11068 buffer: ___T::RecvBuffer,
11069 ) -> ::core::result::Result<
11070 (),
11071 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11072 > {
11073 match ordinal {
11074 ordinal => {
11075 handler.on_unknown_interaction(ordinal).await;
11076 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11077 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11078 } else {
11079 Ok(())
11080 }
11081 }
11082 }
11083 }
11084
11085 async fn on_two_way(
11086 handler: &mut ___H,
11087 ordinal: u64,
11088 flexibility: ::fidl_next::protocol::Flexibility,
11089 buffer: ___T::RecvBuffer,
11090 responder: ::fidl_next::protocol::Responder<___T>,
11091 ) -> ::core::result::Result<
11092 (),
11093 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11094 > {
11095 match ordinal {
11096 4987781442555247955 => {
11097 let responder = ::fidl_next::Responder::from_untyped(responder);
11098
11099 handler.get_next(responder).await;
11100 Ok(())
11101 }
11102
11103 ordinal => {
11104 handler.on_unknown_interaction(ordinal).await;
11105 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11106 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11107 } else {
11108 responder
11109 .respond(
11110 ordinal,
11111 flexibility,
11112 ::fidl_next::Flexible::<()>::FrameworkErr(
11113 ::fidl_next::FrameworkError::UnknownMethod,
11114 ),
11115 )
11116 .expect("encoding a framework error should never fail")
11117 .await?;
11118 Ok(())
11119 }
11120 }
11121 }
11122 }
11123}
11124
11125#[derive(PartialEq, Debug)]
11127pub struct DictionaryRouter;
11128
11129impl ::fidl_next::Discoverable for DictionaryRouter {
11130 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
11131}
11132
11133#[cfg(target_os = "fuchsia")]
11134impl ::fidl_next::HasTransport for DictionaryRouter {
11135 type Transport = ::fidl_next::fuchsia::zx::Channel;
11136}
11137
11138pub mod dictionary_router {
11139 pub mod prelude {
11140 pub use crate::{
11141 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
11142 dictionary_router,
11143 };
11144
11145 pub use crate::natural::DictionaryRouterRouteResponse;
11146
11147 pub use crate::natural::RouteRequest;
11148
11149 pub use crate::natural::RouterError;
11150 }
11151
11152 pub struct Route;
11153
11154 impl ::fidl_next::Method for Route {
11155 const ORDINAL: u64 = 8164012099375978399;
11156 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11157 ::fidl_next::protocol::Flexibility::Flexible;
11158
11159 type Protocol = crate::DictionaryRouter;
11160
11161 type Request = crate::wire::RouteRequest<'static>;
11162 }
11163
11164 impl ::fidl_next::TwoWayMethod for Route {
11165 type Response = ::fidl_next::WireFlexibleResult<
11166 'static,
11167 crate::wire::DictionaryRouterRouteResponse,
11168 crate::wire::RouterError,
11169 >;
11170 }
11171
11172 impl<___R> ::fidl_next::Respond<___R> for Route {
11173 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11174
11175 fn respond(response: ___R) -> Self::Output {
11176 ::fidl_next::FlexibleResult::Ok(response)
11177 }
11178 }
11179
11180 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11181 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11182
11183 fn respond_err(response: ___R) -> Self::Output {
11184 ::fidl_next::FlexibleResult::Err(response)
11185 }
11186 }
11187
11188 mod ___detail {
11189 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
11190 where
11191 ___T: ::fidl_next::Transport,
11192 {
11193 type Client = DictionaryRouterClient<___T>;
11194 type Server = DictionaryRouterServer<___T>;
11195 }
11196
11197 #[repr(transparent)]
11199 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
11200 #[allow(dead_code)]
11201 client: ::fidl_next::protocol::Client<___T>,
11202 }
11203
11204 impl<___T> DictionaryRouterClient<___T>
11205 where
11206 ___T: ::fidl_next::Transport,
11207 {
11208 pub fn route_with<___R>(
11209 &self,
11210 request: ___R,
11211 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11212 where
11213 ___R: ::fidl_next::Encode<
11214 crate::wire::RouteRequest<'static>,
11215 <___T as ::fidl_next::Transport>::SendBuffer,
11216 >,
11217 {
11218 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11219 8164012099375978399,
11220 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11221 request,
11222 ))
11223 }
11224 }
11225
11226 #[repr(transparent)]
11228 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
11229 server: ::fidl_next::protocol::Server<___T>,
11230 }
11231
11232 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
11233 }
11234}
11235
11236pub trait DictionaryRouterClientHandler<
11240 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11241 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11242>
11243{
11244 fn on_unknown_interaction(
11245 &mut self,
11246 ordinal: u64,
11247 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11248 ::core::future::ready(())
11249 }
11250}
11251
11252impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11253where
11254 ___T: ::fidl_next::Transport,
11255{
11256 async fn on_unknown_interaction(&mut self, _: u64) {}
11257}
11258
11259impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
11260where
11261 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
11262 ___T: ::fidl_next::Transport,
11263{
11264 async fn on_event(
11265 handler: &mut ___H,
11266 ordinal: u64,
11267 flexibility: ::fidl_next::protocol::Flexibility,
11268 buffer: ___T::RecvBuffer,
11269 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11270 match ordinal {
11271 ordinal => {
11272 handler.on_unknown_interaction(ordinal).await;
11273 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11274 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11275 } else {
11276 Ok(())
11277 }
11278 }
11279 }
11280 }
11281}
11282
11283pub trait DictionaryRouterServerHandler<
11287 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11288 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11289>
11290{
11291 fn route(
11292 &mut self,
11293
11294 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
11295
11296 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
11297 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11298
11299 fn on_unknown_interaction(
11300 &mut self,
11301 ordinal: u64,
11302 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11303 ::core::future::ready(())
11304 }
11305}
11306
11307impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
11308where
11309 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
11310 ___T: ::fidl_next::Transport,
11311 <dictionary_router::Route as ::fidl_next::Method>::Request:
11312 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11313{
11314 async fn on_one_way(
11315 handler: &mut ___H,
11316 ordinal: u64,
11317 flexibility: ::fidl_next::protocol::Flexibility,
11318 buffer: ___T::RecvBuffer,
11319 ) -> ::core::result::Result<
11320 (),
11321 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11322 > {
11323 match ordinal {
11324 ordinal => {
11325 handler.on_unknown_interaction(ordinal).await;
11326 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11327 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11328 } else {
11329 Ok(())
11330 }
11331 }
11332 }
11333 }
11334
11335 async fn on_two_way(
11336 handler: &mut ___H,
11337 ordinal: u64,
11338 flexibility: ::fidl_next::protocol::Flexibility,
11339 buffer: ___T::RecvBuffer,
11340 responder: ::fidl_next::protocol::Responder<___T>,
11341 ) -> ::core::result::Result<
11342 (),
11343 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11344 > {
11345 match ordinal {
11346 8164012099375978399 => {
11347 let responder = ::fidl_next::Responder::from_untyped(responder);
11348
11349 match ::fidl_next::DecoderExt::decode(buffer) {
11350 Ok(decoded) => {
11351 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11352 Ok(())
11353 }
11354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11355 ordinal: 8164012099375978399,
11356 error,
11357 }),
11358 }
11359 }
11360
11361 ordinal => {
11362 handler.on_unknown_interaction(ordinal).await;
11363 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11364 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11365 } else {
11366 responder
11367 .respond(
11368 ordinal,
11369 flexibility,
11370 ::fidl_next::Flexible::<()>::FrameworkErr(
11371 ::fidl_next::FrameworkError::UnknownMethod,
11372 ),
11373 )
11374 .expect("encoding a framework error should never fail")
11375 .await?;
11376 Ok(())
11377 }
11378 }
11379 }
11380 }
11381}
11382
11383#[derive(PartialEq, Debug)]
11385pub struct DirConnectorRouter;
11386
11387impl ::fidl_next::Discoverable for DirConnectorRouter {
11388 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
11389}
11390
11391#[cfg(target_os = "fuchsia")]
11392impl ::fidl_next::HasTransport for DirConnectorRouter {
11393 type Transport = ::fidl_next::fuchsia::zx::Channel;
11394}
11395
11396pub mod dir_connector_router {
11397 pub mod prelude {
11398 pub use crate::{
11399 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
11400 dir_connector_router,
11401 };
11402
11403 pub use crate::natural::DirConnectorRouterRouteResponse;
11404
11405 pub use crate::natural::RouteRequest;
11406
11407 pub use crate::natural::RouterError;
11408 }
11409
11410 pub struct Route;
11411
11412 impl ::fidl_next::Method for Route {
11413 const ORDINAL: u64 = 972231070188342848;
11414 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11415 ::fidl_next::protocol::Flexibility::Flexible;
11416
11417 type Protocol = crate::DirConnectorRouter;
11418
11419 type Request = crate::wire::RouteRequest<'static>;
11420 }
11421
11422 impl ::fidl_next::TwoWayMethod for Route {
11423 type Response = ::fidl_next::WireFlexibleResult<
11424 'static,
11425 crate::wire::DirConnectorRouterRouteResponse,
11426 crate::wire::RouterError,
11427 >;
11428 }
11429
11430 impl<___R> ::fidl_next::Respond<___R> for Route {
11431 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11432
11433 fn respond(response: ___R) -> Self::Output {
11434 ::fidl_next::FlexibleResult::Ok(response)
11435 }
11436 }
11437
11438 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11439 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11440
11441 fn respond_err(response: ___R) -> Self::Output {
11442 ::fidl_next::FlexibleResult::Err(response)
11443 }
11444 }
11445
11446 mod ___detail {
11447 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
11448 where
11449 ___T: ::fidl_next::Transport,
11450 {
11451 type Client = DirConnectorRouterClient<___T>;
11452 type Server = DirConnectorRouterServer<___T>;
11453 }
11454
11455 #[repr(transparent)]
11457 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
11458 #[allow(dead_code)]
11459 client: ::fidl_next::protocol::Client<___T>,
11460 }
11461
11462 impl<___T> DirConnectorRouterClient<___T>
11463 where
11464 ___T: ::fidl_next::Transport,
11465 {
11466 pub fn route_with<___R>(
11467 &self,
11468 request: ___R,
11469 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11470 where
11471 ___R: ::fidl_next::Encode<
11472 crate::wire::RouteRequest<'static>,
11473 <___T as ::fidl_next::Transport>::SendBuffer,
11474 >,
11475 {
11476 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11477 972231070188342848,
11478 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11479 request,
11480 ))
11481 }
11482 }
11483
11484 #[repr(transparent)]
11486 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
11487 server: ::fidl_next::protocol::Server<___T>,
11488 }
11489
11490 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
11491 }
11492}
11493
11494pub trait DirConnectorRouterClientHandler<
11498 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11499 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11500>
11501{
11502 fn on_unknown_interaction(
11503 &mut self,
11504 ordinal: u64,
11505 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11506 ::core::future::ready(())
11507 }
11508}
11509
11510impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11511where
11512 ___T: ::fidl_next::Transport,
11513{
11514 async fn on_unknown_interaction(&mut self, _: u64) {}
11515}
11516
11517impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
11518where
11519 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
11520 ___T: ::fidl_next::Transport,
11521{
11522 async fn on_event(
11523 handler: &mut ___H,
11524 ordinal: u64,
11525 flexibility: ::fidl_next::protocol::Flexibility,
11526 buffer: ___T::RecvBuffer,
11527 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11528 match ordinal {
11529 ordinal => {
11530 handler.on_unknown_interaction(ordinal).await;
11531 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11532 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11533 } else {
11534 Ok(())
11535 }
11536 }
11537 }
11538 }
11539}
11540
11541pub trait DirConnectorRouterServerHandler<
11545 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11546 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11547>
11548{
11549 fn route(
11550 &mut self,
11551
11552 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
11553
11554 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
11555 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11556
11557 fn on_unknown_interaction(
11558 &mut self,
11559 ordinal: u64,
11560 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11561 ::core::future::ready(())
11562 }
11563}
11564
11565impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
11566where
11567 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
11568 ___T: ::fidl_next::Transport,
11569 <dir_connector_router::Route as ::fidl_next::Method>::Request:
11570 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11571{
11572 async fn on_one_way(
11573 handler: &mut ___H,
11574 ordinal: u64,
11575 flexibility: ::fidl_next::protocol::Flexibility,
11576 buffer: ___T::RecvBuffer,
11577 ) -> ::core::result::Result<
11578 (),
11579 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11580 > {
11581 match ordinal {
11582 ordinal => {
11583 handler.on_unknown_interaction(ordinal).await;
11584 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11585 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11586 } else {
11587 Ok(())
11588 }
11589 }
11590 }
11591 }
11592
11593 async fn on_two_way(
11594 handler: &mut ___H,
11595 ordinal: u64,
11596 flexibility: ::fidl_next::protocol::Flexibility,
11597 buffer: ___T::RecvBuffer,
11598 responder: ::fidl_next::protocol::Responder<___T>,
11599 ) -> ::core::result::Result<
11600 (),
11601 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11602 > {
11603 match ordinal {
11604 972231070188342848 => {
11605 let responder = ::fidl_next::Responder::from_untyped(responder);
11606
11607 match ::fidl_next::DecoderExt::decode(buffer) {
11608 Ok(decoded) => {
11609 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11610 Ok(())
11611 }
11612 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11613 ordinal: 972231070188342848,
11614 error,
11615 }),
11616 }
11617 }
11618
11619 ordinal => {
11620 handler.on_unknown_interaction(ordinal).await;
11621 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11622 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11623 } else {
11624 responder
11625 .respond(
11626 ordinal,
11627 flexibility,
11628 ::fidl_next::Flexible::<()>::FrameworkErr(
11629 ::fidl_next::FrameworkError::UnknownMethod,
11630 ),
11631 )
11632 .expect("encoding a framework error should never fail")
11633 .await?;
11634 Ok(())
11635 }
11636 }
11637 }
11638 }
11639}
11640
11641#[derive(PartialEq, Debug)]
11643pub struct DirEntryRouter;
11644
11645impl ::fidl_next::Discoverable for DirEntryRouter {
11646 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
11647}
11648
11649#[cfg(target_os = "fuchsia")]
11650impl ::fidl_next::HasTransport for DirEntryRouter {
11651 type Transport = ::fidl_next::fuchsia::zx::Channel;
11652}
11653
11654pub mod dir_entry_router {
11655 pub mod prelude {
11656 pub use crate::{
11657 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
11658 dir_entry_router,
11659 };
11660
11661 pub use crate::natural::DirEntryRouterRouteResponse;
11662
11663 pub use crate::natural::RouteRequest;
11664
11665 pub use crate::natural::RouterError;
11666 }
11667
11668 pub struct Route;
11669
11670 impl ::fidl_next::Method for Route {
11671 const ORDINAL: u64 = 1929392218567642066;
11672 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11673 ::fidl_next::protocol::Flexibility::Flexible;
11674
11675 type Protocol = crate::DirEntryRouter;
11676
11677 type Request = crate::wire::RouteRequest<'static>;
11678 }
11679
11680 impl ::fidl_next::TwoWayMethod for Route {
11681 type Response = ::fidl_next::WireFlexibleResult<
11682 'static,
11683 crate::wire::DirEntryRouterRouteResponse,
11684 crate::wire::RouterError,
11685 >;
11686 }
11687
11688 impl<___R> ::fidl_next::Respond<___R> for Route {
11689 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11690
11691 fn respond(response: ___R) -> Self::Output {
11692 ::fidl_next::FlexibleResult::Ok(response)
11693 }
11694 }
11695
11696 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11697 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11698
11699 fn respond_err(response: ___R) -> Self::Output {
11700 ::fidl_next::FlexibleResult::Err(response)
11701 }
11702 }
11703
11704 mod ___detail {
11705 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
11706 where
11707 ___T: ::fidl_next::Transport,
11708 {
11709 type Client = DirEntryRouterClient<___T>;
11710 type Server = DirEntryRouterServer<___T>;
11711 }
11712
11713 #[repr(transparent)]
11715 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
11716 #[allow(dead_code)]
11717 client: ::fidl_next::protocol::Client<___T>,
11718 }
11719
11720 impl<___T> DirEntryRouterClient<___T>
11721 where
11722 ___T: ::fidl_next::Transport,
11723 {
11724 pub fn route_with<___R>(
11725 &self,
11726 request: ___R,
11727 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11728 where
11729 ___R: ::fidl_next::Encode<
11730 crate::wire::RouteRequest<'static>,
11731 <___T as ::fidl_next::Transport>::SendBuffer,
11732 >,
11733 {
11734 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11735 1929392218567642066,
11736 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11737 request,
11738 ))
11739 }
11740 }
11741
11742 #[repr(transparent)]
11744 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
11745 server: ::fidl_next::protocol::Server<___T>,
11746 }
11747
11748 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
11749 }
11750}
11751
11752pub trait DirEntryRouterClientHandler<
11756 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11757 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11758>
11759{
11760 fn on_unknown_interaction(
11761 &mut self,
11762 ordinal: u64,
11763 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11764 ::core::future::ready(())
11765 }
11766}
11767
11768impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11769where
11770 ___T: ::fidl_next::Transport,
11771{
11772 async fn on_unknown_interaction(&mut self, _: u64) {}
11773}
11774
11775impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
11776where
11777 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
11778 ___T: ::fidl_next::Transport,
11779{
11780 async fn on_event(
11781 handler: &mut ___H,
11782 ordinal: u64,
11783 flexibility: ::fidl_next::protocol::Flexibility,
11784 buffer: ___T::RecvBuffer,
11785 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11786 match ordinal {
11787 ordinal => {
11788 handler.on_unknown_interaction(ordinal).await;
11789 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11790 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11791 } else {
11792 Ok(())
11793 }
11794 }
11795 }
11796 }
11797}
11798
11799pub trait DirEntryRouterServerHandler<
11803 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11804 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11805>
11806{
11807 fn route(
11808 &mut self,
11809
11810 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
11811
11812 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
11813 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11814
11815 fn on_unknown_interaction(
11816 &mut self,
11817 ordinal: u64,
11818 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11819 ::core::future::ready(())
11820 }
11821}
11822
11823impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
11824where
11825 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
11826 ___T: ::fidl_next::Transport,
11827 <dir_entry_router::Route as ::fidl_next::Method>::Request:
11828 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11829{
11830 async fn on_one_way(
11831 handler: &mut ___H,
11832 ordinal: u64,
11833 flexibility: ::fidl_next::protocol::Flexibility,
11834 buffer: ___T::RecvBuffer,
11835 ) -> ::core::result::Result<
11836 (),
11837 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11838 > {
11839 match ordinal {
11840 ordinal => {
11841 handler.on_unknown_interaction(ordinal).await;
11842 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11843 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11844 } else {
11845 Ok(())
11846 }
11847 }
11848 }
11849 }
11850
11851 async fn on_two_way(
11852 handler: &mut ___H,
11853 ordinal: u64,
11854 flexibility: ::fidl_next::protocol::Flexibility,
11855 buffer: ___T::RecvBuffer,
11856 responder: ::fidl_next::protocol::Responder<___T>,
11857 ) -> ::core::result::Result<
11858 (),
11859 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11860 > {
11861 match ordinal {
11862 1929392218567642066 => {
11863 let responder = ::fidl_next::Responder::from_untyped(responder);
11864
11865 match ::fidl_next::DecoderExt::decode(buffer) {
11866 Ok(decoded) => {
11867 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11868 Ok(())
11869 }
11870 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11871 ordinal: 1929392218567642066,
11872 error,
11873 }),
11874 }
11875 }
11876
11877 ordinal => {
11878 handler.on_unknown_interaction(ordinal).await;
11879 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11880 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11881 } else {
11882 responder
11883 .respond(
11884 ordinal,
11885 flexibility,
11886 ::fidl_next::Flexible::<()>::FrameworkErr(
11887 ::fidl_next::FrameworkError::UnknownMethod,
11888 ),
11889 )
11890 .expect("encoding a framework error should never fail")
11891 .await?;
11892 Ok(())
11893 }
11894 }
11895 }
11896 }
11897}
11898
11899#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
11901#[derive(PartialEq, Debug)]
11902pub struct DirReceiver;
11903
11904impl ::fidl_next::Discoverable for DirReceiver {
11905 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
11906}
11907
11908#[cfg(target_os = "fuchsia")]
11909impl ::fidl_next::HasTransport for DirReceiver {
11910 type Transport = ::fidl_next::fuchsia::zx::Channel;
11911}
11912
11913pub mod dir_receiver {
11914 pub mod prelude {
11915 pub use crate::{
11916 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
11917 };
11918
11919 pub use crate::natural::DirReceiverReceiveRequest;
11920 }
11921
11922 pub struct Receive;
11923
11924 impl ::fidl_next::Method for Receive {
11925 const ORDINAL: u64 = 926684461087488948;
11926 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11927 ::fidl_next::protocol::Flexibility::Flexible;
11928
11929 type Protocol = crate::DirReceiver;
11930
11931 type Request = crate::wire::DirReceiverReceiveRequest;
11932 }
11933
11934 mod ___detail {
11935 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
11936 where
11937 ___T: ::fidl_next::Transport,
11938 {
11939 type Client = DirReceiverClient<___T>;
11940 type Server = DirReceiverServer<___T>;
11941 }
11942
11943 #[repr(transparent)]
11945 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
11946 #[allow(dead_code)]
11947 client: ::fidl_next::protocol::Client<___T>,
11948 }
11949
11950 impl<___T> DirReceiverClient<___T>
11951 where
11952 ___T: ::fidl_next::Transport,
11953 {
11954 #[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"]
11955 pub fn receive(
11956 &self,
11957
11958 channel: impl ::fidl_next::Encode<
11959 ::fidl_next::ServerEnd<
11960 ::fidl_next_fuchsia_io::Directory,
11961 ::fidl_next::fuchsia::WireChannel,
11962 >,
11963 <___T as ::fidl_next::Transport>::SendBuffer,
11964 >,
11965 ) -> ::fidl_next::SendFuture<'_, ___T>
11966 where
11967 <___T as ::fidl_next::Transport>::SendBuffer:
11968 ::fidl_next::encoder::InternalHandleEncoder,
11969 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11970 {
11971 self.receive_with(crate::generic::DirReceiverReceiveRequest { channel })
11972 }
11973
11974 #[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"]
11975 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
11976 where
11977 ___R: ::fidl_next::Encode<
11978 crate::wire::DirReceiverReceiveRequest,
11979 <___T as ::fidl_next::Transport>::SendBuffer,
11980 >,
11981 {
11982 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
11983 926684461087488948,
11984 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
11985 request,
11986 ))
11987 }
11988 }
11989
11990 #[repr(transparent)]
11992 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
11993 server: ::fidl_next::protocol::Server<___T>,
11994 }
11995
11996 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
11997 }
11998}
11999
12000pub trait DirReceiverClientHandler<
12004 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12005 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12006>
12007{
12008 fn on_unknown_interaction(
12009 &mut self,
12010 ordinal: u64,
12011 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12012 ::core::future::ready(())
12013 }
12014}
12015
12016impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
12017where
12018 ___T: ::fidl_next::Transport,
12019{
12020 async fn on_unknown_interaction(&mut self, _: u64) {}
12021}
12022
12023impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
12024where
12025 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
12026 ___T: ::fidl_next::Transport,
12027{
12028 async fn on_event(
12029 handler: &mut ___H,
12030 ordinal: u64,
12031 flexibility: ::fidl_next::protocol::Flexibility,
12032 buffer: ___T::RecvBuffer,
12033 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12034 match ordinal {
12035 ordinal => {
12036 handler.on_unknown_interaction(ordinal).await;
12037 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12038 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12039 } else {
12040 Ok(())
12041 }
12042 }
12043 }
12044 }
12045}
12046
12047pub trait DirReceiverServerHandler<
12051 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12052 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12053>
12054{
12055 #[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"]
12056 fn receive(
12057 &mut self,
12058
12059 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
12060 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12061
12062 fn on_unknown_interaction(
12063 &mut self,
12064 ordinal: u64,
12065 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12066 ::core::future::ready(())
12067 }
12068}
12069
12070impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
12071where
12072 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
12073 ___T: ::fidl_next::Transport,
12074 <dir_receiver::Receive as ::fidl_next::Method>::Request:
12075 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12076{
12077 async fn on_one_way(
12078 handler: &mut ___H,
12079 ordinal: u64,
12080 flexibility: ::fidl_next::protocol::Flexibility,
12081 buffer: ___T::RecvBuffer,
12082 ) -> ::core::result::Result<
12083 (),
12084 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12085 > {
12086 match ordinal {
12087 926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
12088 Ok(decoded) => {
12089 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
12090 Ok(())
12091 }
12092 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12093 ordinal: 926684461087488948,
12094 error,
12095 }),
12096 },
12097
12098 ordinal => {
12099 handler.on_unknown_interaction(ordinal).await;
12100 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12101 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12102 } else {
12103 Ok(())
12104 }
12105 }
12106 }
12107 }
12108
12109 async fn on_two_way(
12110 handler: &mut ___H,
12111 ordinal: u64,
12112 flexibility: ::fidl_next::protocol::Flexibility,
12113 buffer: ___T::RecvBuffer,
12114 responder: ::fidl_next::protocol::Responder<___T>,
12115 ) -> ::core::result::Result<
12116 (),
12117 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12118 > {
12119 match ordinal {
12120 ordinal => {
12121 handler.on_unknown_interaction(ordinal).await;
12122 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12123 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12124 } else {
12125 responder
12126 .respond(
12127 ordinal,
12128 flexibility,
12129 ::fidl_next::Flexible::<()>::FrameworkErr(
12130 ::fidl_next::FrameworkError::UnknownMethod,
12131 ),
12132 )
12133 .expect("encoding a framework error should never fail")
12134 .await?;
12135 Ok(())
12136 }
12137 }
12138 }
12139 }
12140}
12141
12142#[derive(PartialEq, Debug)]
12144pub struct DirectoryRouter;
12145
12146impl ::fidl_next::Discoverable for DirectoryRouter {
12147 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
12148}
12149
12150#[cfg(target_os = "fuchsia")]
12151impl ::fidl_next::HasTransport for DirectoryRouter {
12152 type Transport = ::fidl_next::fuchsia::zx::Channel;
12153}
12154
12155pub mod directory_router {
12156 pub mod prelude {
12157 pub use crate::{
12158 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
12159 directory_router,
12160 };
12161
12162 pub use crate::natural::DirectoryRouterRouteResponse;
12163
12164 pub use crate::natural::RouteRequest;
12165
12166 pub use crate::natural::RouterError;
12167 }
12168
12169 pub struct Route;
12170
12171 impl ::fidl_next::Method for Route {
12172 const ORDINAL: u64 = 7510716014181158689;
12173 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12174 ::fidl_next::protocol::Flexibility::Flexible;
12175
12176 type Protocol = crate::DirectoryRouter;
12177
12178 type Request = crate::wire::RouteRequest<'static>;
12179 }
12180
12181 impl ::fidl_next::TwoWayMethod for Route {
12182 type Response = ::fidl_next::WireFlexibleResult<
12183 'static,
12184 crate::wire::DirectoryRouterRouteResponse,
12185 crate::wire::RouterError,
12186 >;
12187 }
12188
12189 impl<___R> ::fidl_next::Respond<___R> for Route {
12190 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12191
12192 fn respond(response: ___R) -> Self::Output {
12193 ::fidl_next::FlexibleResult::Ok(response)
12194 }
12195 }
12196
12197 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12198 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12199
12200 fn respond_err(response: ___R) -> Self::Output {
12201 ::fidl_next::FlexibleResult::Err(response)
12202 }
12203 }
12204
12205 mod ___detail {
12206 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
12207 where
12208 ___T: ::fidl_next::Transport,
12209 {
12210 type Client = DirectoryRouterClient<___T>;
12211 type Server = DirectoryRouterServer<___T>;
12212 }
12213
12214 #[repr(transparent)]
12216 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
12217 #[allow(dead_code)]
12218 client: ::fidl_next::protocol::Client<___T>,
12219 }
12220
12221 impl<___T> DirectoryRouterClient<___T>
12222 where
12223 ___T: ::fidl_next::Transport,
12224 {
12225 pub fn route_with<___R>(
12226 &self,
12227 request: ___R,
12228 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12229 where
12230 ___R: ::fidl_next::Encode<
12231 crate::wire::RouteRequest<'static>,
12232 <___T as ::fidl_next::Transport>::SendBuffer,
12233 >,
12234 {
12235 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12236 7510716014181158689,
12237 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12238 request,
12239 ))
12240 }
12241 }
12242
12243 #[repr(transparent)]
12245 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
12246 server: ::fidl_next::protocol::Server<___T>,
12247 }
12248
12249 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12250 }
12251}
12252
12253pub trait DirectoryRouterClientHandler<
12257 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12258 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12259>
12260{
12261 fn on_unknown_interaction(
12262 &mut self,
12263 ordinal: u64,
12264 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12265 ::core::future::ready(())
12266 }
12267}
12268
12269impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12270where
12271 ___T: ::fidl_next::Transport,
12272{
12273 async fn on_unknown_interaction(&mut self, _: u64) {}
12274}
12275
12276impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
12277where
12278 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
12279 ___T: ::fidl_next::Transport,
12280{
12281 async fn on_event(
12282 handler: &mut ___H,
12283 ordinal: u64,
12284 flexibility: ::fidl_next::protocol::Flexibility,
12285 buffer: ___T::RecvBuffer,
12286 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12287 match ordinal {
12288 ordinal => {
12289 handler.on_unknown_interaction(ordinal).await;
12290 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12291 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12292 } else {
12293 Ok(())
12294 }
12295 }
12296 }
12297 }
12298}
12299
12300pub trait DirectoryRouterServerHandler<
12304 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12305 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12306>
12307{
12308 fn route(
12309 &mut self,
12310
12311 request: ::fidl_next::Request<directory_router::Route, ___T>,
12312
12313 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
12314 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12315
12316 fn on_unknown_interaction(
12317 &mut self,
12318 ordinal: u64,
12319 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12320 ::core::future::ready(())
12321 }
12322}
12323
12324impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
12325where
12326 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
12327 ___T: ::fidl_next::Transport,
12328 <directory_router::Route as ::fidl_next::Method>::Request:
12329 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12330{
12331 async fn on_one_way(
12332 handler: &mut ___H,
12333 ordinal: u64,
12334 flexibility: ::fidl_next::protocol::Flexibility,
12335 buffer: ___T::RecvBuffer,
12336 ) -> ::core::result::Result<
12337 (),
12338 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12339 > {
12340 match ordinal {
12341 ordinal => {
12342 handler.on_unknown_interaction(ordinal).await;
12343 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12344 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12345 } else {
12346 Ok(())
12347 }
12348 }
12349 }
12350 }
12351
12352 async fn on_two_way(
12353 handler: &mut ___H,
12354 ordinal: u64,
12355 flexibility: ::fidl_next::protocol::Flexibility,
12356 buffer: ___T::RecvBuffer,
12357 responder: ::fidl_next::protocol::Responder<___T>,
12358 ) -> ::core::result::Result<
12359 (),
12360 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12361 > {
12362 match ordinal {
12363 7510716014181158689 => {
12364 let responder = ::fidl_next::Responder::from_untyped(responder);
12365
12366 match ::fidl_next::DecoderExt::decode(buffer) {
12367 Ok(decoded) => {
12368 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12369 Ok(())
12370 }
12371 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12372 ordinal: 7510716014181158689,
12373 error,
12374 }),
12375 }
12376 }
12377
12378 ordinal => {
12379 handler.on_unknown_interaction(ordinal).await;
12380 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12381 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12382 } else {
12383 responder
12384 .respond(
12385 ordinal,
12386 flexibility,
12387 ::fidl_next::Flexible::<()>::FrameworkErr(
12388 ::fidl_next::FrameworkError::UnknownMethod,
12389 ),
12390 )
12391 .expect("encoding a framework error should never fail")
12392 .await?;
12393 Ok(())
12394 }
12395 }
12396 }
12397 }
12398}
12399
12400#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
12402#[derive(PartialEq, Debug)]
12403pub struct Receiver;
12404
12405impl ::fidl_next::Discoverable for Receiver {
12406 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
12407}
12408
12409#[cfg(target_os = "fuchsia")]
12410impl ::fidl_next::HasTransport for Receiver {
12411 type Transport = ::fidl_next::fuchsia::zx::Channel;
12412}
12413
12414pub mod receiver {
12415 pub mod prelude {
12416 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
12417
12418 pub use crate::natural::ProtocolPayload;
12419 }
12420
12421 pub struct Receive;
12422
12423 impl ::fidl_next::Method for Receive {
12424 const ORDINAL: u64 = 340832707723008660;
12425 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12426 ::fidl_next::protocol::Flexibility::Flexible;
12427
12428 type Protocol = crate::Receiver;
12429
12430 type Request = crate::wire::ProtocolPayload;
12431 }
12432
12433 mod ___detail {
12434 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
12435 where
12436 ___T: ::fidl_next::Transport,
12437 {
12438 type Client = ReceiverClient<___T>;
12439 type Server = ReceiverServer<___T>;
12440 }
12441
12442 #[repr(transparent)]
12444 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
12445 #[allow(dead_code)]
12446 client: ::fidl_next::protocol::Client<___T>,
12447 }
12448
12449 impl<___T> ReceiverClient<___T>
12450 where
12451 ___T: ::fidl_next::Transport,
12452 {
12453 #[doc = " Sends a channel to this receiver.\n"]
12454 pub fn receive(
12455 &self,
12456
12457 channel: impl ::fidl_next::Encode<
12458 ::fidl_next::fuchsia::WireChannel,
12459 <___T as ::fidl_next::Transport>::SendBuffer,
12460 >,
12461 ) -> ::fidl_next::SendFuture<'_, ___T>
12462 where
12463 <___T as ::fidl_next::Transport>::SendBuffer:
12464 ::fidl_next::encoder::InternalHandleEncoder,
12465 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12466 {
12467 self.receive_with(crate::generic::ProtocolPayload { channel })
12468 }
12469
12470 #[doc = " Sends a channel to this receiver.\n"]
12471 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
12472 where
12473 ___R: ::fidl_next::Encode<
12474 crate::wire::ProtocolPayload,
12475 <___T as ::fidl_next::Transport>::SendBuffer,
12476 >,
12477 {
12478 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
12479 340832707723008660,
12480 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
12481 request,
12482 ))
12483 }
12484 }
12485
12486 #[repr(transparent)]
12488 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
12489 server: ::fidl_next::protocol::Server<___T>,
12490 }
12491
12492 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
12493 }
12494}
12495
12496pub trait ReceiverClientHandler<
12500 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12501 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12502>
12503{
12504 fn on_unknown_interaction(
12505 &mut self,
12506 ordinal: u64,
12507 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12508 ::core::future::ready(())
12509 }
12510}
12511
12512impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
12513where
12514 ___T: ::fidl_next::Transport,
12515{
12516 async fn on_unknown_interaction(&mut self, _: u64) {}
12517}
12518
12519impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
12520where
12521 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
12522 ___T: ::fidl_next::Transport,
12523{
12524 async fn on_event(
12525 handler: &mut ___H,
12526 ordinal: u64,
12527 flexibility: ::fidl_next::protocol::Flexibility,
12528 buffer: ___T::RecvBuffer,
12529 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12530 match ordinal {
12531 ordinal => {
12532 handler.on_unknown_interaction(ordinal).await;
12533 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12534 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12535 } else {
12536 Ok(())
12537 }
12538 }
12539 }
12540 }
12541}
12542
12543pub trait ReceiverServerHandler<
12547 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12548 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12549>
12550{
12551 #[doc = " Sends a channel to this receiver.\n"]
12552 fn receive(
12553 &mut self,
12554
12555 request: ::fidl_next::Request<receiver::Receive, ___T>,
12556 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12557
12558 fn on_unknown_interaction(
12559 &mut self,
12560 ordinal: u64,
12561 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12562 ::core::future::ready(())
12563 }
12564}
12565
12566impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
12567where
12568 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
12569 ___T: ::fidl_next::Transport,
12570 <receiver::Receive as ::fidl_next::Method>::Request:
12571 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12572{
12573 async fn on_one_way(
12574 handler: &mut ___H,
12575 ordinal: u64,
12576 flexibility: ::fidl_next::protocol::Flexibility,
12577 buffer: ___T::RecvBuffer,
12578 ) -> ::core::result::Result<
12579 (),
12580 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12581 > {
12582 match ordinal {
12583 340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
12584 Ok(decoded) => {
12585 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
12586 Ok(())
12587 }
12588 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12589 ordinal: 340832707723008660,
12590 error,
12591 }),
12592 },
12593
12594 ordinal => {
12595 handler.on_unknown_interaction(ordinal).await;
12596 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12597 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12598 } else {
12599 Ok(())
12600 }
12601 }
12602 }
12603 }
12604
12605 async fn on_two_way(
12606 handler: &mut ___H,
12607 ordinal: u64,
12608 flexibility: ::fidl_next::protocol::Flexibility,
12609 buffer: ___T::RecvBuffer,
12610 responder: ::fidl_next::protocol::Responder<___T>,
12611 ) -> ::core::result::Result<
12612 (),
12613 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12614 > {
12615 match ordinal {
12616 ordinal => {
12617 handler.on_unknown_interaction(ordinal).await;
12618 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12619 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12620 } else {
12621 responder
12622 .respond(
12623 ordinal,
12624 flexibility,
12625 ::fidl_next::Flexible::<()>::FrameworkErr(
12626 ::fidl_next::FrameworkError::UnknownMethod,
12627 ),
12628 )
12629 .expect("encoding a framework error should never fail")
12630 .await?;
12631 Ok(())
12632 }
12633 }
12634 }
12635 }
12636}
12637
12638pub use fidl_next_common_fuchsia_component_sandbox::*;
12639
12640pub mod compat {
12642
12643 pub use fidl_next_common_fuchsia_component_sandbox::compat::*;
12644
12645 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
12646 for ::fidl_fuchsia_component_sandbox::DictionaryRef
12647 {
12648 #[inline]
12649 fn compat_from(value: crate::DictionaryRef) -> Self {
12650 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12651 }
12652 }
12653
12654 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
12655 for crate::DictionaryRef
12656 {
12657 #[inline]
12658 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
12659 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12660 }
12661 }
12662
12663 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
12664 #[inline]
12665 fn compat_from(value: crate::Connector) -> Self {
12666 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12667 }
12668 }
12669
12670 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
12671 #[inline]
12672 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
12673 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12674 }
12675 }
12676
12677 impl ::fidl_next::CompatFrom<crate::DirConnector>
12678 for ::fidl_fuchsia_component_sandbox::DirConnector
12679 {
12680 #[inline]
12681 fn compat_from(value: crate::DirConnector) -> Self {
12682 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12683 }
12684 }
12685
12686 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
12687 for crate::DirConnector
12688 {
12689 #[inline]
12690 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
12691 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12692 }
12693 }
12694
12695 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
12696 #[inline]
12697 fn compat_from(value: crate::DirEntry) -> Self {
12698 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12699 }
12700 }
12701
12702 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
12703 #[inline]
12704 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
12705 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12706 }
12707 }
12708
12709 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
12710 fn compat_from(value: crate::Capability) -> Self {
12711 match value {
12712 crate::Capability::Unit(value) => {
12713 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
12714 }
12715
12716 crate::Capability::Handle(value) => {
12717 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
12718 }
12719
12720 crate::Capability::Data(value) => {
12721 Self::Data(::fidl_next::CompatFrom::compat_from(value))
12722 }
12723
12724 crate::Capability::Dictionary(value) => {
12725 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
12726 }
12727
12728 crate::Capability::Connector(value) => {
12729 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
12730 }
12731
12732 crate::Capability::DirConnector(value) => {
12733 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
12734 }
12735
12736 crate::Capability::Directory(value) => {
12737 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
12738 }
12739
12740 crate::Capability::DirEntry(value) => {
12741 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
12742 }
12743
12744 crate::Capability::ConnectorRouter(value) => {
12745 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12746 }
12747
12748 crate::Capability::DictionaryRouter(value) => {
12749 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
12750 }
12751
12752 crate::Capability::DirEntryRouter(value) => {
12753 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
12754 }
12755
12756 crate::Capability::DataRouter(value) => {
12757 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
12758 }
12759
12760 crate::Capability::DirConnectorRouter(value) => {
12761 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12762 }
12763
12764 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
12765 Self::__SourceBreaking { unknown_ordinal }
12766 }
12767 }
12768 }
12769 }
12770
12771 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
12772 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
12773 match value {
12774 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
12775 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
12776 }
12777
12778 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
12779 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
12780 }
12781
12782 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
12783 Self::Data(::fidl_next::CompatFrom::compat_from(value))
12784 }
12785
12786 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
12787 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
12788 }
12789
12790 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
12791 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
12792 }
12793
12794 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
12795 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
12796 }
12797
12798 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
12799 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
12800 }
12801
12802 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
12803 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
12804 }
12805
12806 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
12807 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12808 }
12809
12810 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
12811 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
12812 }
12813
12814 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
12815 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
12816 }
12817
12818 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
12819 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
12820 }
12821
12822 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
12823 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12824 }
12825
12826 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
12827 unknown_ordinal,
12828 } => Self::UnknownOrdinal_(unknown_ordinal),
12829 }
12830 }
12831 }
12832
12833 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
12834 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
12835 {
12836 #[inline]
12837 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
12838 Self {
12839 id: ::fidl_next::CompatFrom::compat_from(value.id),
12840
12841 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
12842 }
12843 }
12844 }
12845
12846 impl
12847 ::fidl_next::CompatFrom<
12848 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
12849 > for crate::CapabilityStoreConnectorCreateRequest
12850 {
12851 #[inline]
12852 fn compat_from(
12853 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
12854 ) -> Self {
12855 Self {
12856 id: ::fidl_next::CompatFrom::compat_from(value.id),
12857
12858 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
12859 }
12860 }
12861 }
12862
12863 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
12864 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
12865 {
12866 #[inline]
12867 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
12868 Self {
12869 id: ::fidl_next::CompatFrom::compat_from(value.id),
12870
12871 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12872 }
12873 }
12874 }
12875
12876 impl
12877 ::fidl_next::CompatFrom<
12878 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
12879 > for crate::CapabilityStoreConnectorOpenRequest
12880 {
12881 #[inline]
12882 fn compat_from(
12883 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
12884 ) -> Self {
12885 Self {
12886 id: ::fidl_next::CompatFrom::compat_from(value.id),
12887
12888 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12889 }
12890 }
12891 }
12892
12893 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
12894 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
12895 {
12896 #[inline]
12897 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
12898 Self {
12899 id: ::fidl_next::CompatFrom::compat_from(value.id),
12900
12901 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
12902 }
12903 }
12904 }
12905
12906 impl
12907 ::fidl_next::CompatFrom<
12908 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
12909 > for crate::CapabilityStoreDictionaryLegacyImportRequest
12910 {
12911 #[inline]
12912 fn compat_from(
12913 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
12914 ) -> Self {
12915 Self {
12916 id: ::fidl_next::CompatFrom::compat_from(value.id),
12917
12918 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
12919 }
12920 }
12921 }
12922
12923 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
12924 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
12925 {
12926 #[inline]
12927 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
12928 Self {
12929 id: ::fidl_next::CompatFrom::compat_from(value.id),
12930
12931 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12932 }
12933 }
12934 }
12935
12936 impl
12937 ::fidl_next::CompatFrom<
12938 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
12939 > for crate::CapabilityStoreDictionaryLegacyExportRequest
12940 {
12941 #[inline]
12942 fn compat_from(
12943 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
12944 ) -> Self {
12945 Self {
12946 id: ::fidl_next::CompatFrom::compat_from(value.id),
12947
12948 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12949 }
12950 }
12951 }
12952
12953 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
12954 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
12955 {
12956 #[inline]
12957 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
12958 Self {
12959 id: ::fidl_next::CompatFrom::compat_from(value.id),
12960
12961 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
12962 }
12963 }
12964 }
12965
12966 impl
12967 ::fidl_next::CompatFrom<
12968 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
12969 > for crate::CapabilityStoreDictionaryKeysRequest
12970 {
12971 #[inline]
12972 fn compat_from(
12973 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
12974 ) -> Self {
12975 Self {
12976 id: ::fidl_next::CompatFrom::compat_from(value.id),
12977
12978 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
12979 }
12980 }
12981 }
12982
12983 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
12984 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
12985 {
12986 #[inline]
12987 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
12988 Self {
12989 id: ::fidl_next::CompatFrom::compat_from(value.id),
12990
12991 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
12992 }
12993 }
12994 }
12995
12996 impl
12997 ::fidl_next::CompatFrom<
12998 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
12999 > for crate::CapabilityStoreDictionaryEnumerateRequest
13000 {
13001 #[inline]
13002 fn compat_from(
13003 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
13004 ) -> Self {
13005 Self {
13006 id: ::fidl_next::CompatFrom::compat_from(value.id),
13007
13008 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13009 }
13010 }
13011 }
13012
13013 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
13014 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
13015 {
13016 #[inline]
13017 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
13018 Self {
13019 id: ::fidl_next::CompatFrom::compat_from(value.id),
13020
13021 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13022 }
13023 }
13024 }
13025
13026 impl
13027 ::fidl_next::CompatFrom<
13028 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
13029 > for crate::CapabilityStoreDictionaryDrainRequest
13030 {
13031 #[inline]
13032 fn compat_from(
13033 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
13034 ) -> Self {
13035 Self {
13036 id: ::fidl_next::CompatFrom::compat_from(value.id),
13037
13038 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13039 }
13040 }
13041 }
13042
13043 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
13044 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
13045 {
13046 #[inline]
13047 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
13048 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
13049 }
13050 }
13051
13052 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
13053 for crate::CapabilityStoreExportResponse
13054 {
13055 #[inline]
13056 fn compat_from(
13057 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
13058 ) -> Self {
13059 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
13060 }
13061 }
13062
13063 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
13064 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
13065 {
13066 #[inline]
13067 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
13068 Self {
13069 id: ::fidl_next::CompatFrom::compat_from(value.id),
13070
13071 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
13072 }
13073 }
13074 }
13075
13076 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
13077 for crate::CapabilityStoreImportRequest
13078 {
13079 #[inline]
13080 fn compat_from(
13081 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
13082 ) -> Self {
13083 Self {
13084 id: ::fidl_next::CompatFrom::compat_from(value.id),
13085
13086 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
13087 }
13088 }
13089 }
13090
13091 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
13092 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
13093 {
13094 #[inline]
13095 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
13096 Self {
13097 id: ::fidl_next::CompatFrom::compat_from(value.id),
13098
13099 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13100 }
13101 }
13102 }
13103
13104 impl
13105 ::fidl_next::CompatFrom<
13106 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13107 > for crate::CapabilityStoreDirConnectorCreateRequest
13108 {
13109 #[inline]
13110 fn compat_from(
13111 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13112 ) -> Self {
13113 Self {
13114 id: ::fidl_next::CompatFrom::compat_from(value.id),
13115
13116 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13117 }
13118 }
13119 }
13120
13121 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
13122 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
13123 {
13124 #[inline]
13125 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
13126 Self {
13127 id: ::fidl_next::CompatFrom::compat_from(value.id),
13128
13129 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13130 }
13131 }
13132 }
13133
13134 impl
13135 ::fidl_next::CompatFrom<
13136 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
13137 > for crate::CapabilityStoreDirConnectorOpenRequest
13138 {
13139 #[inline]
13140 fn compat_from(
13141 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
13142 ) -> Self {
13143 Self {
13144 id: ::fidl_next::CompatFrom::compat_from(value.id),
13145
13146 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13147 }
13148 }
13149 }
13150
13151 #[cfg(target_os = "fuchsia")]
13152 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
13155
13156 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
13157 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
13158 {
13159 fn compat_from(_: crate::CapabilityStore) -> Self {
13160 Self
13161 }
13162 }
13163
13164 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
13165 for crate::CapabilityStore
13166 {
13167 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
13168 Self
13169 }
13170 }
13171
13172 #[cfg(target_os = "fuchsia")]
13173
13174 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
13175 for crate::CapabilityStore
13176 {
13177 fn client_compat_from(
13178 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
13179 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13180 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13181 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13182 ::fidl_next::ClientDispatcher::new(client_end)
13183 }
13184 }
13185
13186 impl ::fidl_next::CompatFrom<crate::InstanceToken>
13187 for ::fidl_fuchsia_component_sandbox::InstanceToken
13188 {
13189 #[inline]
13190 fn compat_from(value: crate::InstanceToken) -> Self {
13191 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13192 }
13193 }
13194
13195 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
13196 for crate::InstanceToken
13197 {
13198 #[inline]
13199 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
13200 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13201 }
13202 }
13203
13204 impl ::fidl_next::CompatFrom<crate::RouteRequest>
13205 for ::fidl_fuchsia_component_sandbox::RouteRequest
13206 {
13207 fn compat_from(value: crate::RouteRequest) -> Self {
13208 Self {
13209 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
13210
13211 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
13212
13213 __source_breaking: ::fidl::marker::SourceBreaking,
13214 }
13215 }
13216 }
13217
13218 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
13219 for crate::RouteRequest
13220 {
13221 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
13222 Self {
13223 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
13224
13225 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
13226 }
13227 }
13228 }
13229
13230 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
13231 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
13232 {
13233 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
13234 match value {
13235 crate::ConnectorRouterRouteResponse::Connector(value) => {
13236 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
13237 }
13238
13239 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
13240 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13241 }
13242 }
13243 }
13244 }
13245
13246 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
13247 for crate::ConnectorRouterRouteResponse
13248 {
13249 fn compat_from(
13250 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
13251 ) -> Self {
13252 match value {
13253 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
13254 value,
13255 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
13256
13257 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
13258 value,
13259 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13260 }
13261 }
13262 }
13263
13264 #[cfg(target_os = "fuchsia")]
13265 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
13268
13269 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
13270 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
13271 {
13272 fn compat_from(_: crate::ConnectorRouter) -> Self {
13273 Self
13274 }
13275 }
13276
13277 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
13278 for crate::ConnectorRouter
13279 {
13280 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
13281 Self
13282 }
13283 }
13284
13285 #[cfg(target_os = "fuchsia")]
13286
13287 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
13288 for crate::ConnectorRouter
13289 {
13290 fn client_compat_from(
13291 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
13292 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13293 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13294 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13295 ::fidl_next::ClientDispatcher::new(client_end)
13296 }
13297 }
13298
13299 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
13300 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
13301 {
13302 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
13303 match value {
13304 crate::DataRouterRouteResponse::Data(value) => {
13305 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13306 }
13307
13308 crate::DataRouterRouteResponse::Unavailable(value) => {
13309 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13310 }
13311 }
13312 }
13313 }
13314
13315 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
13316 for crate::DataRouterRouteResponse
13317 {
13318 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
13319 match value {
13320 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
13321 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13322 }
13323
13324 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
13325 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13326 }
13327 }
13328 }
13329 }
13330
13331 #[cfg(target_os = "fuchsia")]
13332 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
13335
13336 impl ::fidl_next::CompatFrom<crate::DataRouter>
13337 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
13338 {
13339 fn compat_from(_: crate::DataRouter) -> Self {
13340 Self
13341 }
13342 }
13343
13344 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
13345 for crate::DataRouter
13346 {
13347 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
13348 Self
13349 }
13350 }
13351
13352 #[cfg(target_os = "fuchsia")]
13353
13354 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
13355 for crate::DataRouter
13356 {
13357 fn client_compat_from(
13358 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
13359 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13360 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13361 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13362 ::fidl_next::ClientDispatcher::new(client_end)
13363 }
13364 }
13365
13366 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
13367 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
13368 {
13369 #[inline]
13370 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
13371 Self {
13372 items: ::fidl_next::CompatFrom::compat_from(value.items),
13373
13374 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13375 }
13376 }
13377 }
13378
13379 impl
13380 ::fidl_next::CompatFrom<
13381 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
13382 > for crate::DictionaryDrainIteratorGetNextResponse
13383 {
13384 #[inline]
13385 fn compat_from(
13386 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
13387 ) -> Self {
13388 Self {
13389 items: ::fidl_next::CompatFrom::compat_from(value.items),
13390
13391 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13392 }
13393 }
13394 }
13395
13396 #[cfg(target_os = "fuchsia")]
13397 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
13400
13401 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
13402 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
13403 {
13404 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
13405 Self
13406 }
13407 }
13408
13409 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
13410 for crate::DictionaryDrainIterator
13411 {
13412 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
13413 Self
13414 }
13415 }
13416
13417 #[cfg(target_os = "fuchsia")]
13418
13419 impl
13420 ::fidl_next::ClientCompatFrom<
13421 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
13422 > for crate::DictionaryDrainIterator
13423 {
13424 fn client_compat_from(
13425 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
13426 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13427 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13428 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13429 ::fidl_next::ClientDispatcher::new(client_end)
13430 }
13431 }
13432
13433 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
13434 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
13435 {
13436 #[inline]
13437 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
13438 Self {
13439 key: ::fidl_next::CompatFrom::compat_from(value.key),
13440
13441 value: ::fidl_next::CompatFrom::compat_from(value.value),
13442 }
13443 }
13444 }
13445
13446 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
13447 for crate::DictionaryOptionalItem
13448 {
13449 #[inline]
13450 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
13451 Self {
13452 key: ::fidl_next::CompatFrom::compat_from(value.key),
13453
13454 value: ::fidl_next::CompatFrom::compat_from(value.value),
13455 }
13456 }
13457 }
13458
13459 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
13460 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
13461 {
13462 #[inline]
13463 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
13464 Self {
13465 items: ::fidl_next::CompatFrom::compat_from(value.items),
13466
13467 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13468 }
13469 }
13470 }
13471
13472 impl
13473 ::fidl_next::CompatFrom<
13474 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
13475 > for crate::DictionaryEnumerateIteratorGetNextResponse
13476 {
13477 #[inline]
13478 fn compat_from(
13479 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
13480 ) -> Self {
13481 Self {
13482 items: ::fidl_next::CompatFrom::compat_from(value.items),
13483
13484 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13485 }
13486 }
13487 }
13488
13489 #[cfg(target_os = "fuchsia")]
13490 pub type DictionaryEnumerateIteratorProxy =
13493 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
13494
13495 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
13496 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
13497 {
13498 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
13499 Self
13500 }
13501 }
13502
13503 impl
13504 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
13505 for crate::DictionaryEnumerateIterator
13506 {
13507 fn compat_from(
13508 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
13509 ) -> Self {
13510 Self
13511 }
13512 }
13513
13514 #[cfg(target_os = "fuchsia")]
13515
13516 impl
13517 ::fidl_next::ClientCompatFrom<
13518 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
13519 > for crate::DictionaryEnumerateIterator
13520 {
13521 fn client_compat_from(
13522 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
13523 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13524 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13525 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13526 ::fidl_next::ClientDispatcher::new(client_end)
13527 }
13528 }
13529
13530 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
13531 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
13532 {
13533 #[inline]
13534 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
13535 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
13536 }
13537 }
13538
13539 impl
13540 ::fidl_next::CompatFrom<
13541 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
13542 > for crate::DictionaryKeysIteratorGetNextResponse
13543 {
13544 #[inline]
13545 fn compat_from(
13546 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
13547 ) -> Self {
13548 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
13549 }
13550 }
13551
13552 #[cfg(target_os = "fuchsia")]
13553 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
13556
13557 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
13558 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
13559 {
13560 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
13561 Self
13562 }
13563 }
13564
13565 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
13566 for crate::DictionaryKeysIterator
13567 {
13568 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
13569 Self
13570 }
13571 }
13572
13573 #[cfg(target_os = "fuchsia")]
13574
13575 impl
13576 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
13577 for crate::DictionaryKeysIterator
13578 {
13579 fn client_compat_from(
13580 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
13581 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13582 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13583 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13584 ::fidl_next::ClientDispatcher::new(client_end)
13585 }
13586 }
13587
13588 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
13589 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
13590 {
13591 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
13592 match value {
13593 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
13594 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
13595 }
13596
13597 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
13598 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13599 }
13600 }
13601 }
13602 }
13603
13604 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
13605 for crate::DictionaryRouterRouteResponse
13606 {
13607 fn compat_from(
13608 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
13609 ) -> Self {
13610 match value {
13611 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
13612 value,
13613 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
13614
13615 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
13616 value,
13617 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13618 }
13619 }
13620 }
13621
13622 #[cfg(target_os = "fuchsia")]
13623 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
13626
13627 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
13628 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
13629 {
13630 fn compat_from(_: crate::DictionaryRouter) -> Self {
13631 Self
13632 }
13633 }
13634
13635 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
13636 for crate::DictionaryRouter
13637 {
13638 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
13639 Self
13640 }
13641 }
13642
13643 #[cfg(target_os = "fuchsia")]
13644
13645 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
13646 for crate::DictionaryRouter
13647 {
13648 fn client_compat_from(
13649 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
13650 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13651 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13652 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13653 ::fidl_next::ClientDispatcher::new(client_end)
13654 }
13655 }
13656
13657 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
13658 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
13659 {
13660 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
13661 match value {
13662 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
13663 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
13664 }
13665
13666 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
13667 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13668 }
13669 }
13670 }
13671 }
13672
13673 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
13674 for crate::DirConnectorRouterRouteResponse
13675 {
13676 fn compat_from(
13677 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
13678 ) -> Self {
13679 match value {
13680 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
13681 value,
13682 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
13683
13684 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
13685 value,
13686 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13687 }
13688 }
13689 }
13690
13691 #[cfg(target_os = "fuchsia")]
13692 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
13695
13696 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
13697 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
13698 {
13699 fn compat_from(_: crate::DirConnectorRouter) -> Self {
13700 Self
13701 }
13702 }
13703
13704 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
13705 for crate::DirConnectorRouter
13706 {
13707 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
13708 Self
13709 }
13710 }
13711
13712 #[cfg(target_os = "fuchsia")]
13713
13714 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
13715 for crate::DirConnectorRouter
13716 {
13717 fn client_compat_from(
13718 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
13719 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13720 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13721 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13722 ::fidl_next::ClientDispatcher::new(client_end)
13723 }
13724 }
13725
13726 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
13727 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
13728 {
13729 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
13730 match value {
13731 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
13732 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13733 }
13734
13735 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
13736 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13737 }
13738 }
13739 }
13740 }
13741
13742 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
13743 for crate::DirEntryRouterRouteResponse
13744 {
13745 fn compat_from(
13746 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
13747 ) -> Self {
13748 match value {
13749 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
13750 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13751 }
13752
13753 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
13754 value,
13755 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13756 }
13757 }
13758 }
13759
13760 #[cfg(target_os = "fuchsia")]
13761 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
13764
13765 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
13766 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
13767 {
13768 fn compat_from(_: crate::DirEntryRouter) -> Self {
13769 Self
13770 }
13771 }
13772
13773 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
13774 for crate::DirEntryRouter
13775 {
13776 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
13777 Self
13778 }
13779 }
13780
13781 #[cfg(target_os = "fuchsia")]
13782
13783 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
13784 for crate::DirEntryRouter
13785 {
13786 fn client_compat_from(
13787 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
13788 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13789 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13790 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13791 ::fidl_next::ClientDispatcher::new(client_end)
13792 }
13793 }
13794
13795 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
13796 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
13797 {
13798 #[inline]
13799 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
13800 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
13801 }
13802 }
13803
13804 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
13805 for crate::DirReceiverReceiveRequest
13806 {
13807 #[inline]
13808 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
13809 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
13810 }
13811 }
13812
13813 #[cfg(target_os = "fuchsia")]
13814 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
13817
13818 impl ::fidl_next::CompatFrom<crate::DirReceiver>
13819 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
13820 {
13821 fn compat_from(_: crate::DirReceiver) -> Self {
13822 Self
13823 }
13824 }
13825
13826 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
13827 for crate::DirReceiver
13828 {
13829 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
13830 Self
13831 }
13832 }
13833
13834 #[cfg(target_os = "fuchsia")]
13835
13836 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
13837 for crate::DirReceiver
13838 {
13839 fn client_compat_from(
13840 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
13841 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13842 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13843 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13844 ::fidl_next::ClientDispatcher::new(client_end)
13845 }
13846 }
13847
13848 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
13849 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
13850 {
13851 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
13852 match value {
13853 crate::DirectoryRouterRouteResponse::Directory(value) => {
13854 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
13855 }
13856
13857 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
13858 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13859 }
13860 }
13861 }
13862 }
13863
13864 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
13865 for crate::DirectoryRouterRouteResponse
13866 {
13867 fn compat_from(
13868 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
13869 ) -> Self {
13870 match value {
13871 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
13872 value,
13873 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
13874
13875 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
13876 value,
13877 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13878 }
13879 }
13880 }
13881
13882 #[cfg(target_os = "fuchsia")]
13883 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
13886
13887 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
13888 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
13889 {
13890 fn compat_from(_: crate::DirectoryRouter) -> Self {
13891 Self
13892 }
13893 }
13894
13895 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
13896 for crate::DirectoryRouter
13897 {
13898 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
13899 Self
13900 }
13901 }
13902
13903 #[cfg(target_os = "fuchsia")]
13904
13905 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
13906 for crate::DirectoryRouter
13907 {
13908 fn client_compat_from(
13909 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
13910 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13911 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13912 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13913 ::fidl_next::ClientDispatcher::new(client_end)
13914 }
13915 }
13916
13917 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
13918 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
13919 {
13920 #[inline]
13921 fn compat_from(value: crate::ProtocolPayload) -> Self {
13922 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
13923 }
13924 }
13925
13926 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
13927 for crate::ProtocolPayload
13928 {
13929 #[inline]
13930 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
13931 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
13932 }
13933 }
13934
13935 #[cfg(target_os = "fuchsia")]
13936 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
13939
13940 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
13941 fn compat_from(_: crate::Receiver) -> Self {
13942 Self
13943 }
13944 }
13945
13946 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
13947 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
13948 Self
13949 }
13950 }
13951
13952 #[cfg(target_os = "fuchsia")]
13953
13954 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
13955 for crate::Receiver
13956 {
13957 fn client_compat_from(
13958 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
13959 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13960 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13961 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13962 ::fidl_next::ClientDispatcher::new(client_end)
13963 }
13964 }
13965}