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::NullableHandle),
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::WireNullableHandle,
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::WireNullableHandle>()
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 CapabilityStoreDirConnectorCreateRequest {
815 pub id: u64,
816
817 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
818 }
819
820 unsafe impl<___E>
821 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
822 for CapabilityStoreDirConnectorCreateRequest
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::CapabilityStoreDirConnectorCreateRequest,
833 >,
834 _: (),
835 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
836 ::fidl_next::munge! {
837 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
838 id,
839 receiver,
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.receiver, encoder_, receiver, ())?;
849
850 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
851
852 Ok(())
853 }
854 }
855
856 unsafe impl<___E>
857 ::fidl_next::EncodeOption<
858 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>,
859 ___E,
860 > for CapabilityStoreDirConnectorCreateRequest
861 where
862 ___E: ::fidl_next::Encoder + ?Sized,
863 CapabilityStoreDirConnectorCreateRequest:
864 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>,
865 {
866 #[inline]
867 fn encode_option(
868 this: ::core::option::Option<Self>,
869 encoder: &mut ___E,
870 out: &mut ::core::mem::MaybeUninit<
871 ::fidl_next::WireBox<
872 'static,
873 crate::wire::CapabilityStoreDirConnectorCreateRequest,
874 >,
875 >,
876 _: (),
877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
878 if let Some(inner) = this {
879 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
880 ::fidl_next::WireBox::encode_present(out);
881 } else {
882 ::fidl_next::WireBox::encode_absent(out);
883 }
884
885 Ok(())
886 }
887 }
888
889 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
890 for CapabilityStoreDirConnectorCreateRequest
891 {
892 #[inline]
893 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
894 Self {
895 id: ::fidl_next::FromWire::from_wire(wire.id),
896
897 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
898 }
899 }
900 }
901
902 #[derive(PartialEq, Debug)]
903 pub struct CapabilityStoreDictionaryLegacyImportRequest {
904 pub id: u64,
905
906 pub client_end: ::fidl_next::fuchsia::zx::Channel,
907 }
908
909 unsafe impl<___E>
910 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
911 for CapabilityStoreDictionaryLegacyImportRequest
912 where
913 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
914 ___E: ::fidl_next::fuchsia::HandleEncoder,
915 {
916 #[inline]
917 fn encode(
918 self,
919 encoder_: &mut ___E,
920 out_: &mut ::core::mem::MaybeUninit<
921 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
922 >,
923 _: (),
924 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
925 ::fidl_next::munge! {
926 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
927 id,
928 client_end,
929
930 } = out_;
931 }
932
933 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
934
935 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
936
937 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
938
939 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
940
941 Ok(())
942 }
943 }
944
945 unsafe impl<___E>
946 ::fidl_next::EncodeOption<
947 ::fidl_next::WireBox<
948 'static,
949 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
950 >,
951 ___E,
952 > for CapabilityStoreDictionaryLegacyImportRequest
953 where
954 ___E: ::fidl_next::Encoder + ?Sized,
955 CapabilityStoreDictionaryLegacyImportRequest:
956 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>,
957 {
958 #[inline]
959 fn encode_option(
960 this: ::core::option::Option<Self>,
961 encoder: &mut ___E,
962 out: &mut ::core::mem::MaybeUninit<
963 ::fidl_next::WireBox<
964 'static,
965 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
966 >,
967 >,
968 _: (),
969 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
970 if let Some(inner) = this {
971 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
972 ::fidl_next::WireBox::encode_present(out);
973 } else {
974 ::fidl_next::WireBox::encode_absent(out);
975 }
976
977 Ok(())
978 }
979 }
980
981 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
982 for CapabilityStoreDictionaryLegacyImportRequest
983 {
984 #[inline]
985 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
986 Self {
987 id: ::fidl_next::FromWire::from_wire(wire.id),
988
989 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
990 }
991 }
992 }
993
994 #[derive(PartialEq, Debug)]
995 pub struct CapabilityStoreDictionaryLegacyExportRequest {
996 pub id: u64,
997
998 pub server_end: ::fidl_next::fuchsia::zx::Channel,
999 }
1000
1001 unsafe impl<___E>
1002 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
1003 for CapabilityStoreDictionaryLegacyExportRequest
1004 where
1005 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1006 ___E: ::fidl_next::fuchsia::HandleEncoder,
1007 {
1008 #[inline]
1009 fn encode(
1010 self,
1011 encoder_: &mut ___E,
1012 out_: &mut ::core::mem::MaybeUninit<
1013 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1014 >,
1015 _: (),
1016 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1017 ::fidl_next::munge! {
1018 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
1019 id,
1020 server_end,
1021
1022 } = out_;
1023 }
1024
1025 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1026
1027 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1028
1029 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
1030
1031 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
1032
1033 Ok(())
1034 }
1035 }
1036
1037 unsafe impl<___E>
1038 ::fidl_next::EncodeOption<
1039 ::fidl_next::WireBox<
1040 'static,
1041 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1042 >,
1043 ___E,
1044 > for CapabilityStoreDictionaryLegacyExportRequest
1045 where
1046 ___E: ::fidl_next::Encoder + ?Sized,
1047 CapabilityStoreDictionaryLegacyExportRequest:
1048 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___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<
1056 'static,
1057 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1058 >,
1059 >,
1060 _: (),
1061 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1062 if let Some(inner) = this {
1063 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1064 ::fidl_next::WireBox::encode_present(out);
1065 } else {
1066 ::fidl_next::WireBox::encode_absent(out);
1067 }
1068
1069 Ok(())
1070 }
1071 }
1072
1073 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
1074 for CapabilityStoreDictionaryLegacyExportRequest
1075 {
1076 #[inline]
1077 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
1078 Self {
1079 id: ::fidl_next::FromWire::from_wire(wire.id),
1080
1081 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
1082 }
1083 }
1084 }
1085
1086 #[derive(PartialEq, Debug)]
1087 pub struct CapabilityStoreDictionaryKeysRequest {
1088 pub id: u64,
1089
1090 pub iterator: ::fidl_next::ServerEnd<
1091 crate::DictionaryKeysIterator,
1092 ::fidl_next::fuchsia::zx::Channel,
1093 >,
1094 }
1095
1096 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
1097 for CapabilityStoreDictionaryKeysRequest
1098 where
1099 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1100 ___E: ::fidl_next::fuchsia::HandleEncoder,
1101 {
1102 #[inline]
1103 fn encode(
1104 self,
1105 encoder_: &mut ___E,
1106 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
1107 _: (),
1108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1109 ::fidl_next::munge! {
1110 let crate::wire::CapabilityStoreDictionaryKeysRequest {
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::CapabilityStoreDictionaryKeysRequest>,
1132 ___E,
1133 > for CapabilityStoreDictionaryKeysRequest
1134 where
1135 ___E: ::fidl_next::Encoder + ?Sized,
1136 CapabilityStoreDictionaryKeysRequest:
1137 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___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<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1145 >,
1146 _: (),
1147 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1148 if let Some(inner) = this {
1149 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1150 ::fidl_next::WireBox::encode_present(out);
1151 } else {
1152 ::fidl_next::WireBox::encode_absent(out);
1153 }
1154
1155 Ok(())
1156 }
1157 }
1158
1159 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
1160 for CapabilityStoreDictionaryKeysRequest
1161 {
1162 #[inline]
1163 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
1164 Self {
1165 id: ::fidl_next::FromWire::from_wire(wire.id),
1166
1167 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1168 }
1169 }
1170 }
1171
1172 #[derive(PartialEq, Debug)]
1173 pub struct CapabilityStoreDictionaryEnumerateRequest {
1174 pub id: u64,
1175
1176 pub iterator: ::fidl_next::ServerEnd<
1177 crate::DictionaryEnumerateIterator,
1178 ::fidl_next::fuchsia::zx::Channel,
1179 >,
1180 }
1181
1182 unsafe impl<___E>
1183 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
1184 for CapabilityStoreDictionaryEnumerateRequest
1185 where
1186 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1187 ___E: ::fidl_next::fuchsia::HandleEncoder,
1188 {
1189 #[inline]
1190 fn encode(
1191 self,
1192 encoder_: &mut ___E,
1193 out_: &mut ::core::mem::MaybeUninit<
1194 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1195 >,
1196 _: (),
1197 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1198 ::fidl_next::munge! {
1199 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
1200 id,
1201 iterator,
1202
1203 } = out_;
1204 }
1205
1206 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1207
1208 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1209
1210 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1211
1212 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1213
1214 Ok(())
1215 }
1216 }
1217
1218 unsafe impl<___E>
1219 ::fidl_next::EncodeOption<
1220 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>,
1221 ___E,
1222 > for CapabilityStoreDictionaryEnumerateRequest
1223 where
1224 ___E: ::fidl_next::Encoder + ?Sized,
1225 CapabilityStoreDictionaryEnumerateRequest:
1226 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>,
1227 {
1228 #[inline]
1229 fn encode_option(
1230 this: ::core::option::Option<Self>,
1231 encoder: &mut ___E,
1232 out: &mut ::core::mem::MaybeUninit<
1233 ::fidl_next::WireBox<
1234 'static,
1235 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1236 >,
1237 >,
1238 _: (),
1239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1240 if let Some(inner) = this {
1241 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1242 ::fidl_next::WireBox::encode_present(out);
1243 } else {
1244 ::fidl_next::WireBox::encode_absent(out);
1245 }
1246
1247 Ok(())
1248 }
1249 }
1250
1251 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
1252 for CapabilityStoreDictionaryEnumerateRequest
1253 {
1254 #[inline]
1255 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
1256 Self {
1257 id: ::fidl_next::FromWire::from_wire(wire.id),
1258
1259 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1260 }
1261 }
1262 }
1263
1264 #[derive(PartialEq, Debug)]
1265 pub struct CapabilityStoreDictionaryDrainRequest {
1266 pub id: u64,
1267
1268 pub iterator: ::core::option::Option<
1269 ::fidl_next::ServerEnd<
1270 crate::DictionaryDrainIterator,
1271 ::fidl_next::fuchsia::zx::Channel,
1272 >,
1273 >,
1274 }
1275
1276 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
1277 for CapabilityStoreDictionaryDrainRequest
1278 where
1279 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1280 ___E: ::fidl_next::fuchsia::HandleEncoder,
1281 {
1282 #[inline]
1283 fn encode(
1284 self,
1285 encoder_: &mut ___E,
1286 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
1287 _: (),
1288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1289 ::fidl_next::munge! {
1290 let crate::wire::CapabilityStoreDictionaryDrainRequest {
1291 id,
1292 iterator,
1293
1294 } = out_;
1295 }
1296
1297 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1298
1299 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1300
1301 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1302
1303 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1304
1305 Ok(())
1306 }
1307 }
1308
1309 unsafe impl<___E>
1310 ::fidl_next::EncodeOption<
1311 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1312 ___E,
1313 > for CapabilityStoreDictionaryDrainRequest
1314 where
1315 ___E: ::fidl_next::Encoder + ?Sized,
1316 CapabilityStoreDictionaryDrainRequest:
1317 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>,
1318 {
1319 #[inline]
1320 fn encode_option(
1321 this: ::core::option::Option<Self>,
1322 encoder: &mut ___E,
1323 out: &mut ::core::mem::MaybeUninit<
1324 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1325 >,
1326 _: (),
1327 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1328 if let Some(inner) = this {
1329 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1330 ::fidl_next::WireBox::encode_present(out);
1331 } else {
1332 ::fidl_next::WireBox::encode_absent(out);
1333 }
1334
1335 Ok(())
1336 }
1337 }
1338
1339 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
1340 for CapabilityStoreDictionaryDrainRequest
1341 {
1342 #[inline]
1343 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
1344 Self {
1345 id: ::fidl_next::FromWire::from_wire(wire.id),
1346
1347 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1348 }
1349 }
1350 }
1351
1352 #[derive(PartialEq, Debug)]
1353 pub struct CapabilityStoreExportResponse {
1354 pub capability: crate::natural::Capability,
1355 }
1356
1357 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
1358 for CapabilityStoreExportResponse
1359 where
1360 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1361 ___E: ::fidl_next::Encoder,
1362 ___E: ::fidl_next::fuchsia::HandleEncoder,
1363 {
1364 #[inline]
1365 fn encode(
1366 self,
1367 encoder_: &mut ___E,
1368 out_: &mut ::core::mem::MaybeUninit<
1369 crate::wire::CapabilityStoreExportResponse<'static>,
1370 >,
1371 _: (),
1372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1373 ::fidl_next::munge! {
1374 let crate::wire::CapabilityStoreExportResponse {
1375 capability,
1376
1377 } = out_;
1378 }
1379
1380 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1381
1382 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1383
1384 Ok(())
1385 }
1386 }
1387
1388 unsafe impl<___E>
1389 ::fidl_next::EncodeOption<
1390 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1391 ___E,
1392 > for CapabilityStoreExportResponse
1393 where
1394 ___E: ::fidl_next::Encoder + ?Sized,
1395 CapabilityStoreExportResponse:
1396 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>,
1397 {
1398 #[inline]
1399 fn encode_option(
1400 this: ::core::option::Option<Self>,
1401 encoder: &mut ___E,
1402 out: &mut ::core::mem::MaybeUninit<
1403 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1404 >,
1405 _: (),
1406 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1407 if let Some(inner) = this {
1408 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1409 ::fidl_next::WireBox::encode_present(out);
1410 } else {
1411 ::fidl_next::WireBox::encode_absent(out);
1412 }
1413
1414 Ok(())
1415 }
1416 }
1417
1418 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
1419 for CapabilityStoreExportResponse
1420 {
1421 #[inline]
1422 fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
1423 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
1424 }
1425 }
1426
1427 #[derive(PartialEq, Debug)]
1428 pub struct CapabilityStoreImportRequest {
1429 pub id: u64,
1430
1431 pub capability: crate::natural::Capability,
1432 }
1433
1434 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
1435 for CapabilityStoreImportRequest
1436 where
1437 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1438 ___E: ::fidl_next::Encoder,
1439 ___E: ::fidl_next::fuchsia::HandleEncoder,
1440 {
1441 #[inline]
1442 fn encode(
1443 self,
1444 encoder_: &mut ___E,
1445 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
1446 _: (),
1447 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1448 ::fidl_next::munge! {
1449 let crate::wire::CapabilityStoreImportRequest {
1450 id,
1451 capability,
1452
1453 } = out_;
1454 }
1455
1456 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1457
1458 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1459
1460 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1461
1462 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1463
1464 Ok(())
1465 }
1466 }
1467
1468 unsafe impl<___E>
1469 ::fidl_next::EncodeOption<
1470 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1471 ___E,
1472 > for CapabilityStoreImportRequest
1473 where
1474 ___E: ::fidl_next::Encoder + ?Sized,
1475 CapabilityStoreImportRequest:
1476 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>,
1477 {
1478 #[inline]
1479 fn encode_option(
1480 this: ::core::option::Option<Self>,
1481 encoder: &mut ___E,
1482 out: &mut ::core::mem::MaybeUninit<
1483 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
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<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
1499 for CapabilityStoreImportRequest
1500 {
1501 #[inline]
1502 fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
1503 Self {
1504 id: ::fidl_next::FromWire::from_wire(wire.id),
1505
1506 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1507 }
1508 }
1509 }
1510
1511 #[derive(PartialEq, Debug, Default)]
1512 pub struct CapabilityStoreDirConnectorOpenRequest {
1513 pub id: ::core::option::Option<u64>,
1514
1515 pub server_end: ::core::option::Option<
1516 ::fidl_next::ServerEnd<
1517 ::fidl_next_fuchsia_io::Directory,
1518 ::fidl_next::fuchsia::zx::Channel,
1519 >,
1520 >,
1521
1522 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
1523
1524 pub path: ::core::option::Option<::std::string::String>,
1525 }
1526
1527 impl CapabilityStoreDirConnectorOpenRequest {
1528 fn __max_ordinal(&self) -> usize {
1529 if self.path.is_some() {
1530 return 4;
1531 }
1532
1533 if self.flags.is_some() {
1534 return 3;
1535 }
1536
1537 if self.server_end.is_some() {
1538 return 2;
1539 }
1540
1541 if self.id.is_some() {
1542 return 1;
1543 }
1544
1545 0
1546 }
1547 }
1548
1549 unsafe impl<___E>
1550 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>, ___E>
1551 for CapabilityStoreDirConnectorOpenRequest
1552 where
1553 ___E: ::fidl_next::Encoder + ?Sized,
1554 ___E: ::fidl_next::fuchsia::HandleEncoder,
1555 {
1556 #[inline]
1557 fn encode(
1558 mut self,
1559 encoder: &mut ___E,
1560 out: &mut ::core::mem::MaybeUninit<
1561 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
1562 >,
1563 _: (),
1564 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1565 ::fidl_next::munge!(let crate::wire::CapabilityStoreDirConnectorOpenRequest { table } = out);
1566
1567 let max_ord = self.__max_ordinal();
1568
1569 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
1570 ::fidl_next::Wire::zero_padding(&mut out);
1571
1572 let mut preallocated =
1573 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
1574
1575 for i in 1..=max_ord {
1576 match i {
1577 4 => {
1578 if let Some(value) = self.path.take() {
1579 ::fidl_next::WireEnvelope::encode_value::<
1580 ::fidl_next::WireString<'static>,
1581 ___E,
1582 >(
1583 value, preallocated.encoder, &mut out, 4095
1584 )?;
1585 } else {
1586 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1587 }
1588 }
1589
1590 3 => {
1591 if let Some(value) = self.flags.take() {
1592 ::fidl_next::WireEnvelope::encode_value::<
1593 ::fidl_next_fuchsia_io::wire::Flags,
1594 ___E,
1595 >(
1596 value, preallocated.encoder, &mut out, ()
1597 )?;
1598 } else {
1599 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1600 }
1601 }
1602
1603 2 => {
1604 if let Some(value) = self.server_end.take() {
1605 ::fidl_next::WireEnvelope::encode_value::<
1606 ::fidl_next::ServerEnd<
1607 ::fidl_next_fuchsia_io::Directory,
1608 ::fidl_next::fuchsia::WireChannel,
1609 >,
1610 ___E,
1611 >(
1612 value, preallocated.encoder, &mut out, ()
1613 )?;
1614 } else {
1615 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1616 }
1617 }
1618
1619 1 => {
1620 if let Some(value) = self.id.take() {
1621 ::fidl_next::WireEnvelope::encode_value::<::fidl_next::WireU64, ___E>(
1622 value,
1623 preallocated.encoder,
1624 &mut out,
1625 (),
1626 )?;
1627 } else {
1628 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1629 }
1630 }
1631
1632 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
1633 }
1634 unsafe {
1635 preallocated.write_next(out.assume_init_ref());
1636 }
1637 }
1638
1639 ::fidl_next::WireTable::encode_len(table, max_ord);
1640
1641 Ok(())
1642 }
1643 }
1644
1645 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>>
1646 for CapabilityStoreDirConnectorOpenRequest
1647 {
1648 #[inline]
1649 fn from_wire(wire_: crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>) -> Self {
1650 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1651
1652 let id = wire_.table.get(1);
1653
1654 let server_end = wire_.table.get(2);
1655
1656 let flags = wire_.table.get(3);
1657
1658 let path = wire_.table.get(4);
1659
1660 Self {
1661 id: id.map(|envelope| {
1662 ::fidl_next::FromWire::from_wire(unsafe {
1663 envelope.read_unchecked::<::fidl_next::WireU64>()
1664 })
1665 }),
1666
1667 server_end: server_end.map(|envelope| {
1668 ::fidl_next::FromWire::from_wire(unsafe {
1669 envelope.read_unchecked::<::fidl_next::ServerEnd<
1670 ::fidl_next_fuchsia_io::Directory,
1671 ::fidl_next::fuchsia::WireChannel,
1672 >>()
1673 })
1674 }),
1675
1676 flags: flags.map(|envelope| {
1677 ::fidl_next::FromWire::from_wire(unsafe {
1678 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
1679 })
1680 }),
1681
1682 path: path.map(|envelope| {
1683 ::fidl_next::FromWire::from_wire(unsafe {
1684 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
1685 })
1686 }),
1687 }
1688 }
1689 }
1690
1691 #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
1692 #[derive(PartialEq, Debug)]
1693 #[repr(C)]
1694 pub struct InstanceToken {
1695 pub token: ::fidl_next::fuchsia::zx::EventPair,
1696 }
1697
1698 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken
1699 where
1700 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1701 ___E: ::fidl_next::fuchsia::HandleEncoder,
1702 {
1703 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
1704 ::fidl_next::CopyOptimization::enable_if(
1705 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
1706 ::fidl_next::fuchsia::WireEventPair,
1707 ___E,
1708 >>::COPY_OPTIMIZATION
1709 .is_enabled(),
1710 )
1711 };
1712
1713 #[inline]
1714 fn encode(
1715 self,
1716 encoder_: &mut ___E,
1717 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
1718 _: (),
1719 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1720 ::fidl_next::munge! {
1721 let crate::wire::InstanceToken {
1722 token,
1723
1724 } = out_;
1725 }
1726
1727 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
1728
1729 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
1730
1731 Ok(())
1732 }
1733 }
1734
1735 unsafe impl<___E>
1736 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::InstanceToken>, ___E>
1737 for InstanceToken
1738 where
1739 ___E: ::fidl_next::Encoder + ?Sized,
1740 InstanceToken: ::fidl_next::Encode<crate::wire::InstanceToken, ___E>,
1741 {
1742 #[inline]
1743 fn encode_option(
1744 this: ::core::option::Option<Self>,
1745 encoder: &mut ___E,
1746 out: &mut ::core::mem::MaybeUninit<
1747 ::fidl_next::WireBox<'static, crate::wire::InstanceToken>,
1748 >,
1749 _: (),
1750 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1751 if let Some(inner) = this {
1752 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1753 ::fidl_next::WireBox::encode_present(out);
1754 } else {
1755 ::fidl_next::WireBox::encode_absent(out);
1756 }
1757
1758 Ok(())
1759 }
1760 }
1761
1762 impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
1763 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
1764 ::fidl_next::CopyOptimization::enable_if(
1765 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1766 ::fidl_next::fuchsia::WireEventPair,
1767 >>::COPY_OPTIMIZATION
1768 .is_enabled(),
1769 )
1770 };
1771
1772 #[inline]
1773 fn from_wire(wire: crate::wire::InstanceToken) -> Self {
1774 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1775 }
1776 }
1777
1778 #[doc = " A request for a route.\n"]
1779 #[derive(PartialEq, Debug, Default)]
1780 pub struct RouteRequest {
1781 pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
1782
1783 pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
1784 }
1785
1786 impl RouteRequest {
1787 fn __max_ordinal(&self) -> usize {
1788 if self.metadata.is_some() {
1789 return 2;
1790 }
1791
1792 if self.requesting.is_some() {
1793 return 1;
1794 }
1795
1796 0
1797 }
1798 }
1799
1800 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouteRequest<'static>, ___E> for RouteRequest
1801 where
1802 ___E: ::fidl_next::Encoder + ?Sized,
1803 ___E: ::fidl_next::fuchsia::HandleEncoder,
1804 {
1805 #[inline]
1806 fn encode(
1807 mut self,
1808 encoder: &mut ___E,
1809 out: &mut ::core::mem::MaybeUninit<crate::wire::RouteRequest<'static>>,
1810 _: (),
1811 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1812 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
1813
1814 let max_ord = self.__max_ordinal();
1815
1816 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
1817 ::fidl_next::Wire::zero_padding(&mut out);
1818
1819 let mut preallocated =
1820 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
1821
1822 for i in 1..=max_ord {
1823 match i {
1824 2 => {
1825 if let Some(value) = self.metadata.take() {
1826 ::fidl_next::WireEnvelope::encode_value::<
1827 crate::wire::DictionaryRef,
1828 ___E,
1829 >(
1830 value, preallocated.encoder, &mut out, ()
1831 )?;
1832 } else {
1833 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1834 }
1835 }
1836
1837 1 => {
1838 if let Some(value) = self.requesting.take() {
1839 ::fidl_next::WireEnvelope::encode_value::<
1840 crate::wire::InstanceToken,
1841 ___E,
1842 >(
1843 value, preallocated.encoder, &mut out, ()
1844 )?;
1845 } else {
1846 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1847 }
1848 }
1849
1850 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
1851 }
1852 unsafe {
1853 preallocated.write_next(out.assume_init_ref());
1854 }
1855 }
1856
1857 ::fidl_next::WireTable::encode_len(table, max_ord);
1858
1859 Ok(())
1860 }
1861 }
1862
1863 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
1864 #[inline]
1865 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
1866 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1867
1868 let requesting = wire_.table.get(1);
1869
1870 let metadata = wire_.table.get(2);
1871
1872 Self {
1873 requesting: requesting.map(|envelope| {
1874 ::fidl_next::FromWire::from_wire(unsafe {
1875 envelope.read_unchecked::<crate::wire::InstanceToken>()
1876 })
1877 }),
1878
1879 metadata: metadata.map(|envelope| {
1880 ::fidl_next::FromWire::from_wire(unsafe {
1881 envelope.read_unchecked::<crate::wire::DictionaryRef>()
1882 })
1883 }),
1884 }
1885 }
1886 }
1887
1888 #[derive(PartialEq, Debug)]
1889 pub enum ConnectorRouterRouteResponse {
1890 Connector(crate::natural::Connector),
1891
1892 Unavailable(crate::natural::Unit),
1893 }
1894
1895 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>
1896 for ConnectorRouterRouteResponse
1897 where
1898 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1899 ___E: ::fidl_next::fuchsia::HandleEncoder,
1900 {
1901 #[inline]
1902 fn encode(
1903 self,
1904 encoder: &mut ___E,
1905 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectorRouterRouteResponse>,
1906 _: (),
1907 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1908 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
1909
1910 match self {
1911 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
1912 ___E,
1913 crate::wire::Connector,
1914 >(value, 1, encoder, raw, ())?,
1915
1916 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
1917 ___E,
1918 crate::wire::Unit,
1919 >(value, 2, encoder, raw, ())?,
1920 }
1921
1922 Ok(())
1923 }
1924 }
1925
1926 unsafe impl<___E>
1927 ::fidl_next::EncodeOption<crate::wire_optional::ConnectorRouterRouteResponse, ___E>
1928 for ConnectorRouterRouteResponse
1929 where
1930 ___E: ?Sized,
1931 ConnectorRouterRouteResponse:
1932 ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>,
1933 {
1934 #[inline]
1935 fn encode_option(
1936 this: ::core::option::Option<Self>,
1937 encoder: &mut ___E,
1938 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConnectorRouterRouteResponse>,
1939 _: (),
1940 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1941 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
1942
1943 if let Some(inner) = this {
1944 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1945 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1946 } else {
1947 ::fidl_next::RawWireUnion::encode_absent(raw);
1948 }
1949
1950 Ok(())
1951 }
1952 }
1953
1954 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
1955 for ConnectorRouterRouteResponse
1956 {
1957 #[inline]
1958 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
1959 let wire = ::core::mem::ManuallyDrop::new(wire);
1960 match wire.raw.ordinal() {
1961 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1962 wire.raw.get().read_unchecked::<crate::wire::Connector>()
1963 })),
1964
1965 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
1966 wire.raw.get().read_unchecked::<crate::wire::Unit>()
1967 })),
1968
1969 _ => unsafe { ::core::hint::unreachable_unchecked() },
1970 }
1971 }
1972 }
1973
1974 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
1975 for ConnectorRouterRouteResponse
1976 {
1977 #[inline]
1978 fn from_wire_option(
1979 wire: crate::wire_optional::ConnectorRouterRouteResponse,
1980 ) -> ::core::option::Option<Self> {
1981 if let Some(inner) = wire.into_option() {
1982 Some(::fidl_next::FromWire::from_wire(inner))
1983 } else {
1984 None
1985 }
1986 }
1987 }
1988
1989 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
1990 for Box<ConnectorRouterRouteResponse>
1991 {
1992 #[inline]
1993 fn from_wire_option(
1994 wire: crate::wire_optional::ConnectorRouterRouteResponse,
1995 ) -> ::core::option::Option<Self> {
1996 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
1997 crate::wire_optional::ConnectorRouterRouteResponse,
1998 >>::from_wire_option(wire)
1999 .map(Box::new)
2000 }
2001 }
2002
2003 #[derive(PartialEq, Debug)]
2004 pub enum DataRouterRouteResponse {
2005 Data(crate::natural::Data),
2006
2007 Unavailable(crate::natural::Unit),
2008 }
2009
2010 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>
2011 for DataRouterRouteResponse
2012 where
2013 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2014 ___E: ::fidl_next::Encoder,
2015 ___E: ::fidl_next::fuchsia::HandleEncoder,
2016 {
2017 #[inline]
2018 fn encode(
2019 self,
2020 encoder: &mut ___E,
2021 out: &mut ::core::mem::MaybeUninit<crate::wire::DataRouterRouteResponse<'static>>,
2022 _: (),
2023 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2024 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
2025
2026 match self {
2027 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
2028 ___E,
2029 crate::wire::Data<'static>,
2030 >(value, 1, encoder, raw, ())?,
2031
2032 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as::<
2033 ___E,
2034 crate::wire::Unit,
2035 >(value, 2, encoder, raw, ())?,
2036 }
2037
2038 Ok(())
2039 }
2040 }
2041
2042 unsafe impl<___E>
2043 ::fidl_next::EncodeOption<crate::wire_optional::DataRouterRouteResponse<'static>, ___E>
2044 for DataRouterRouteResponse
2045 where
2046 ___E: ?Sized,
2047 DataRouterRouteResponse:
2048 ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>,
2049 {
2050 #[inline]
2051 fn encode_option(
2052 this: ::core::option::Option<Self>,
2053 encoder: &mut ___E,
2054 out: &mut ::core::mem::MaybeUninit<
2055 crate::wire_optional::DataRouterRouteResponse<'static>,
2056 >,
2057 _: (),
2058 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2059 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2060
2061 if let Some(inner) = this {
2062 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2063 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2064 } else {
2065 ::fidl_next::RawWireUnion::encode_absent(raw);
2066 }
2067
2068 Ok(())
2069 }
2070 }
2071
2072 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
2073 for DataRouterRouteResponse
2074 {
2075 #[inline]
2076 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
2077 let wire = ::core::mem::ManuallyDrop::new(wire);
2078 match wire.raw.ordinal() {
2079 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
2080 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
2081 })),
2082
2083 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2084 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2085 })),
2086
2087 _ => unsafe { ::core::hint::unreachable_unchecked() },
2088 }
2089 }
2090 }
2091
2092 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2093 for DataRouterRouteResponse
2094 {
2095 #[inline]
2096 fn from_wire_option(
2097 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2098 ) -> ::core::option::Option<Self> {
2099 if let Some(inner) = wire.into_option() {
2100 Some(::fidl_next::FromWire::from_wire(inner))
2101 } else {
2102 None
2103 }
2104 }
2105 }
2106
2107 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2108 for Box<DataRouterRouteResponse>
2109 {
2110 #[inline]
2111 fn from_wire_option(
2112 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2113 ) -> ::core::option::Option<Self> {
2114 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
2115 crate::wire_optional::DataRouterRouteResponse<'de>,
2116 >>::from_wire_option(wire)
2117 .map(Box::new)
2118 }
2119 }
2120
2121 #[derive(PartialEq, Debug)]
2122 pub struct DictionaryDrainIteratorGetNextResponse {
2123 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
2124
2125 pub end_id: u64,
2126 }
2127
2128 unsafe impl<___E>
2129 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
2130 for DictionaryDrainIteratorGetNextResponse
2131 where
2132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2133 ___E: ::fidl_next::Encoder,
2134 ___E: ::fidl_next::fuchsia::HandleEncoder,
2135 {
2136 #[inline]
2137 fn encode(
2138 self,
2139 encoder_: &mut ___E,
2140 out_: &mut ::core::mem::MaybeUninit<
2141 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2142 >,
2143 _: (),
2144 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2145 ::fidl_next::munge! {
2146 let crate::wire::DictionaryDrainIteratorGetNextResponse {
2147 items,
2148 end_id,
2149
2150 } = out_;
2151 }
2152
2153 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2154
2155 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2156 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2157
2158 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2159
2160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2161
2162 Ok(())
2163 }
2164 }
2165
2166 unsafe impl<___E>
2167 ::fidl_next::EncodeOption<
2168 ::fidl_next::WireBox<
2169 'static,
2170 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2171 >,
2172 ___E,
2173 > for DictionaryDrainIteratorGetNextResponse
2174 where
2175 ___E: ::fidl_next::Encoder + ?Sized,
2176 DictionaryDrainIteratorGetNextResponse:
2177 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>,
2178 {
2179 #[inline]
2180 fn encode_option(
2181 this: ::core::option::Option<Self>,
2182 encoder: &mut ___E,
2183 out: &mut ::core::mem::MaybeUninit<
2184 ::fidl_next::WireBox<
2185 'static,
2186 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2187 >,
2188 >,
2189 _: (),
2190 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2191 if let Some(inner) = this {
2192 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2193 ::fidl_next::WireBox::encode_present(out);
2194 } else {
2195 ::fidl_next::WireBox::encode_absent(out);
2196 }
2197
2198 Ok(())
2199 }
2200 }
2201
2202 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
2203 for DictionaryDrainIteratorGetNextResponse
2204 {
2205 #[inline]
2206 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
2207 Self {
2208 items: ::fidl_next::FromWire::from_wire(wire.items),
2209
2210 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2211 }
2212 }
2213 }
2214
2215 #[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"]
2216 #[derive(PartialEq, Debug)]
2217 pub struct DictionaryOptionalItem {
2218 pub key: ::std::string::String,
2219
2220 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
2221 }
2222
2223 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
2224 for DictionaryOptionalItem
2225 where
2226 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2227 ___E: ::fidl_next::Encoder,
2228 ___E: ::fidl_next::fuchsia::HandleEncoder,
2229 {
2230 #[inline]
2231 fn encode(
2232 self,
2233 encoder_: &mut ___E,
2234 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
2235 _: (),
2236 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2237 ::fidl_next::munge! {
2238 let crate::wire::DictionaryOptionalItem {
2239 key,
2240 value,
2241
2242 } = out_;
2243 }
2244
2245 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2246
2247 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2248 ::fidl_next::Constrained::validate(_field, 255)?;
2249
2250 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2251
2252 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2253
2254 Ok(())
2255 }
2256 }
2257
2258 unsafe impl<___E>
2259 ::fidl_next::EncodeOption<
2260 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2261 ___E,
2262 > for DictionaryOptionalItem
2263 where
2264 ___E: ::fidl_next::Encoder + ?Sized,
2265 DictionaryOptionalItem:
2266 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>,
2267 {
2268 #[inline]
2269 fn encode_option(
2270 this: ::core::option::Option<Self>,
2271 encoder: &mut ___E,
2272 out: &mut ::core::mem::MaybeUninit<
2273 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2274 >,
2275 _: (),
2276 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2277 if let Some(inner) = this {
2278 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2279 ::fidl_next::WireBox::encode_present(out);
2280 } else {
2281 ::fidl_next::WireBox::encode_absent(out);
2282 }
2283
2284 Ok(())
2285 }
2286 }
2287
2288 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
2289 for DictionaryOptionalItem
2290 {
2291 #[inline]
2292 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
2293 Self {
2294 key: ::fidl_next::FromWire::from_wire(wire.key),
2295
2296 value: ::fidl_next::FromWire::from_wire(wire.value),
2297 }
2298 }
2299 }
2300
2301 #[derive(PartialEq, Debug)]
2302 pub struct DictionaryEnumerateIteratorGetNextResponse {
2303 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
2304
2305 pub end_id: u64,
2306 }
2307
2308 unsafe impl<___E>
2309 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
2310 for DictionaryEnumerateIteratorGetNextResponse
2311 where
2312 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2313 ___E: ::fidl_next::Encoder,
2314 ___E: ::fidl_next::fuchsia::HandleEncoder,
2315 {
2316 #[inline]
2317 fn encode(
2318 self,
2319 encoder_: &mut ___E,
2320 out_: &mut ::core::mem::MaybeUninit<
2321 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2322 >,
2323 _: (),
2324 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2325 ::fidl_next::munge! {
2326 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
2327 items,
2328 end_id,
2329
2330 } = out_;
2331 }
2332
2333 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2334
2335 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2336 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2337
2338 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2339
2340 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2341
2342 Ok(())
2343 }
2344 }
2345
2346 unsafe impl<___E>
2347 ::fidl_next::EncodeOption<
2348 ::fidl_next::WireBox<
2349 'static,
2350 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2351 >,
2352 ___E,
2353 > for DictionaryEnumerateIteratorGetNextResponse
2354 where
2355 ___E: ::fidl_next::Encoder + ?Sized,
2356 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<
2357 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2358 ___E,
2359 >,
2360 {
2361 #[inline]
2362 fn encode_option(
2363 this: ::core::option::Option<Self>,
2364 encoder: &mut ___E,
2365 out: &mut ::core::mem::MaybeUninit<
2366 ::fidl_next::WireBox<
2367 'static,
2368 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2369 >,
2370 >,
2371 _: (),
2372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2373 if let Some(inner) = this {
2374 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2375 ::fidl_next::WireBox::encode_present(out);
2376 } else {
2377 ::fidl_next::WireBox::encode_absent(out);
2378 }
2379
2380 Ok(())
2381 }
2382 }
2383
2384 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
2385 for DictionaryEnumerateIteratorGetNextResponse
2386 {
2387 #[inline]
2388 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
2389 Self {
2390 items: ::fidl_next::FromWire::from_wire(wire.items),
2391
2392 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2393 }
2394 }
2395 }
2396
2397 #[derive(PartialEq, Debug)]
2398 pub struct DictionaryKeysIteratorGetNextResponse {
2399 pub keys: ::std::vec::Vec<::std::string::String>,
2400 }
2401
2402 unsafe impl<___E>
2403 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
2404 for DictionaryKeysIteratorGetNextResponse
2405 where
2406 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2407 ___E: ::fidl_next::Encoder,
2408 ___E: ::fidl_next::fuchsia::HandleEncoder,
2409 {
2410 #[inline]
2411 fn encode(
2412 self,
2413 encoder_: &mut ___E,
2414 out_: &mut ::core::mem::MaybeUninit<
2415 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2416 >,
2417 _: (),
2418 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2419 ::fidl_next::munge! {
2420 let crate::wire::DictionaryKeysIteratorGetNextResponse {
2421 keys,
2422
2423 } = out_;
2424 }
2425
2426 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
2427
2428 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
2429 ::fidl_next::Constrained::validate(_field, (128, 255))?;
2430
2431 Ok(())
2432 }
2433 }
2434
2435 unsafe impl<___E>
2436 ::fidl_next::EncodeOption<
2437 ::fidl_next::WireBox<
2438 'static,
2439 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2440 >,
2441 ___E,
2442 > for DictionaryKeysIteratorGetNextResponse
2443 where
2444 ___E: ::fidl_next::Encoder + ?Sized,
2445 DictionaryKeysIteratorGetNextResponse:
2446 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>,
2447 {
2448 #[inline]
2449 fn encode_option(
2450 this: ::core::option::Option<Self>,
2451 encoder: &mut ___E,
2452 out: &mut ::core::mem::MaybeUninit<
2453 ::fidl_next::WireBox<
2454 'static,
2455 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2456 >,
2457 >,
2458 _: (),
2459 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2460 if let Some(inner) = this {
2461 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2462 ::fidl_next::WireBox::encode_present(out);
2463 } else {
2464 ::fidl_next::WireBox::encode_absent(out);
2465 }
2466
2467 Ok(())
2468 }
2469 }
2470
2471 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
2472 for DictionaryKeysIteratorGetNextResponse
2473 {
2474 #[inline]
2475 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
2476 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
2477 }
2478 }
2479
2480 #[derive(PartialEq, Debug)]
2481 pub enum DictionaryRouterRouteResponse {
2482 Dictionary(crate::natural::DictionaryRef),
2483
2484 Unavailable(crate::natural::Unit),
2485 }
2486
2487 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>
2488 for DictionaryRouterRouteResponse
2489 where
2490 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2491 ___E: ::fidl_next::fuchsia::HandleEncoder,
2492 {
2493 #[inline]
2494 fn encode(
2495 self,
2496 encoder: &mut ___E,
2497 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRouterRouteResponse>,
2498 _: (),
2499 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2500 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
2501
2502 match self {
2503 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2504 ___E,
2505 crate::wire::DictionaryRef,
2506 >(value, 1, encoder, raw, ())?,
2507
2508 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2509 ___E,
2510 crate::wire::Unit,
2511 >(value, 2, encoder, raw, ())?,
2512 }
2513
2514 Ok(())
2515 }
2516 }
2517
2518 unsafe impl<___E>
2519 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryRouterRouteResponse, ___E>
2520 for DictionaryRouterRouteResponse
2521 where
2522 ___E: ?Sized,
2523 DictionaryRouterRouteResponse:
2524 ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>,
2525 {
2526 #[inline]
2527 fn encode_option(
2528 this: ::core::option::Option<Self>,
2529 encoder: &mut ___E,
2530 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryRouterRouteResponse>,
2531 _: (),
2532 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2533 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2534
2535 if let Some(inner) = this {
2536 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2537 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2538 } else {
2539 ::fidl_next::RawWireUnion::encode_absent(raw);
2540 }
2541
2542 Ok(())
2543 }
2544 }
2545
2546 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
2547 for DictionaryRouterRouteResponse
2548 {
2549 #[inline]
2550 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
2551 let wire = ::core::mem::ManuallyDrop::new(wire);
2552 match wire.raw.ordinal() {
2553 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
2554 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
2555 })),
2556
2557 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2558 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2559 })),
2560
2561 _ => unsafe { ::core::hint::unreachable_unchecked() },
2562 }
2563 }
2564 }
2565
2566 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2567 for DictionaryRouterRouteResponse
2568 {
2569 #[inline]
2570 fn from_wire_option(
2571 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2572 ) -> ::core::option::Option<Self> {
2573 if let Some(inner) = wire.into_option() {
2574 Some(::fidl_next::FromWire::from_wire(inner))
2575 } else {
2576 None
2577 }
2578 }
2579 }
2580
2581 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2582 for Box<DictionaryRouterRouteResponse>
2583 {
2584 #[inline]
2585 fn from_wire_option(
2586 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2587 ) -> ::core::option::Option<Self> {
2588 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
2589 crate::wire_optional::DictionaryRouterRouteResponse,
2590 >>::from_wire_option(wire)
2591 .map(Box::new)
2592 }
2593 }
2594
2595 #[derive(PartialEq, Debug)]
2596 pub enum DirConnectorRouterRouteResponse {
2597 DirConnector(crate::natural::DirConnector),
2598
2599 Unavailable(crate::natural::Unit),
2600 }
2601
2602 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>
2603 for DirConnectorRouterRouteResponse
2604 where
2605 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2606 ___E: ::fidl_next::fuchsia::HandleEncoder,
2607 {
2608 #[inline]
2609 fn encode(
2610 self,
2611 encoder: &mut ___E,
2612 out: &mut ::core::mem::MaybeUninit<crate::wire::DirConnectorRouterRouteResponse>,
2613 _: (),
2614 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2615 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2616
2617 match self {
2618 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2619 ___E,
2620 crate::wire::DirConnector,
2621 >(value, 1, encoder, raw, ())?,
2622
2623 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2624 ___E,
2625 crate::wire::Unit,
2626 >(value, 2, encoder, raw, ())?,
2627 }
2628
2629 Ok(())
2630 }
2631 }
2632
2633 unsafe impl<___E>
2634 ::fidl_next::EncodeOption<crate::wire_optional::DirConnectorRouterRouteResponse, ___E>
2635 for DirConnectorRouterRouteResponse
2636 where
2637 ___E: ?Sized,
2638 DirConnectorRouterRouteResponse:
2639 ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>,
2640 {
2641 #[inline]
2642 fn encode_option(
2643 this: ::core::option::Option<Self>,
2644 encoder: &mut ___E,
2645 out: &mut ::core::mem::MaybeUninit<
2646 crate::wire_optional::DirConnectorRouterRouteResponse,
2647 >,
2648 _: (),
2649 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2650 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2651
2652 if let Some(inner) = this {
2653 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2654 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2655 } else {
2656 ::fidl_next::RawWireUnion::encode_absent(raw);
2657 }
2658
2659 Ok(())
2660 }
2661 }
2662
2663 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
2664 for DirConnectorRouterRouteResponse
2665 {
2666 #[inline]
2667 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
2668 let wire = ::core::mem::ManuallyDrop::new(wire);
2669 match wire.raw.ordinal() {
2670 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
2671 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
2672 })),
2673
2674 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2675 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2676 })),
2677
2678 _ => unsafe { ::core::hint::unreachable_unchecked() },
2679 }
2680 }
2681 }
2682
2683 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
2684 for DirConnectorRouterRouteResponse
2685 {
2686 #[inline]
2687 fn from_wire_option(
2688 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
2689 ) -> ::core::option::Option<Self> {
2690 if let Some(inner) = wire.into_option() {
2691 Some(::fidl_next::FromWire::from_wire(inner))
2692 } else {
2693 None
2694 }
2695 }
2696 }
2697
2698 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
2699 for Box<DirConnectorRouterRouteResponse>
2700 {
2701 #[inline]
2702 fn from_wire_option(
2703 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
2704 ) -> ::core::option::Option<Self> {
2705 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
2706 crate::wire_optional::DirConnectorRouterRouteResponse,
2707 >>::from_wire_option(wire)
2708 .map(Box::new)
2709 }
2710 }
2711
2712 #[derive(PartialEq, Debug)]
2713 pub enum DirEntryRouterRouteResponse {
2714 DirEntry(crate::natural::DirEntry),
2715
2716 Unavailable(crate::natural::Unit),
2717 }
2718
2719 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>
2720 for DirEntryRouterRouteResponse
2721 where
2722 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2723 ___E: ::fidl_next::fuchsia::HandleEncoder,
2724 {
2725 #[inline]
2726 fn encode(
2727 self,
2728 encoder: &mut ___E,
2729 out: &mut ::core::mem::MaybeUninit<crate::wire::DirEntryRouterRouteResponse>,
2730 _: (),
2731 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2732 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
2733
2734 match self {
2735 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2736 ___E,
2737 crate::wire::DirEntry,
2738 >(value, 1, encoder, raw, ())?,
2739
2740 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2741 ___E,
2742 crate::wire::Unit,
2743 >(value, 2, encoder, raw, ())?,
2744 }
2745
2746 Ok(())
2747 }
2748 }
2749
2750 unsafe impl<___E>
2751 ::fidl_next::EncodeOption<crate::wire_optional::DirEntryRouterRouteResponse, ___E>
2752 for DirEntryRouterRouteResponse
2753 where
2754 ___E: ?Sized,
2755 DirEntryRouterRouteResponse:
2756 ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>,
2757 {
2758 #[inline]
2759 fn encode_option(
2760 this: ::core::option::Option<Self>,
2761 encoder: &mut ___E,
2762 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirEntryRouterRouteResponse>,
2763 _: (),
2764 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2766
2767 if let Some(inner) = this {
2768 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2769 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2770 } else {
2771 ::fidl_next::RawWireUnion::encode_absent(raw);
2772 }
2773
2774 Ok(())
2775 }
2776 }
2777
2778 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
2779 for DirEntryRouterRouteResponse
2780 {
2781 #[inline]
2782 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
2783 let wire = ::core::mem::ManuallyDrop::new(wire);
2784 match wire.raw.ordinal() {
2785 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
2786 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
2787 })),
2788
2789 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2790 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2791 })),
2792
2793 _ => unsafe { ::core::hint::unreachable_unchecked() },
2794 }
2795 }
2796 }
2797
2798 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
2799 for DirEntryRouterRouteResponse
2800 {
2801 #[inline]
2802 fn from_wire_option(
2803 wire: crate::wire_optional::DirEntryRouterRouteResponse,
2804 ) -> ::core::option::Option<Self> {
2805 if let Some(inner) = wire.into_option() {
2806 Some(::fidl_next::FromWire::from_wire(inner))
2807 } else {
2808 None
2809 }
2810 }
2811 }
2812
2813 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
2814 for Box<DirEntryRouterRouteResponse>
2815 {
2816 #[inline]
2817 fn from_wire_option(
2818 wire: crate::wire_optional::DirEntryRouterRouteResponse,
2819 ) -> ::core::option::Option<Self> {
2820 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
2821 crate::wire_optional::DirEntryRouterRouteResponse,
2822 >>::from_wire_option(wire)
2823 .map(Box::new)
2824 }
2825 }
2826
2827 #[derive(PartialEq, Debug, Default)]
2828 pub struct DirReceiverReceiveRequest {
2829 pub channel: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
2830
2831 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
2832
2833 pub subdir: ::core::option::Option<::std::string::String>,
2834 }
2835
2836 impl DirReceiverReceiveRequest {
2837 fn __max_ordinal(&self) -> usize {
2838 if self.subdir.is_some() {
2839 return 3;
2840 }
2841
2842 if self.flags.is_some() {
2843 return 2;
2844 }
2845
2846 if self.channel.is_some() {
2847 return 1;
2848 }
2849
2850 0
2851 }
2852 }
2853
2854 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest<'static>, ___E>
2855 for DirReceiverReceiveRequest
2856 where
2857 ___E: ::fidl_next::Encoder + ?Sized,
2858 ___E: ::fidl_next::fuchsia::HandleEncoder,
2859 {
2860 #[inline]
2861 fn encode(
2862 mut self,
2863 encoder: &mut ___E,
2864 out: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest<'static>>,
2865 _: (),
2866 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2867 ::fidl_next::munge!(let crate::wire::DirReceiverReceiveRequest { table } = out);
2868
2869 let max_ord = self.__max_ordinal();
2870
2871 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
2872 ::fidl_next::Wire::zero_padding(&mut out);
2873
2874 let mut preallocated =
2875 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
2876
2877 for i in 1..=max_ord {
2878 match i {
2879 3 => {
2880 if let Some(value) = self.subdir.take() {
2881 ::fidl_next::WireEnvelope::encode_value::<
2882 ::fidl_next::WireString<'static>,
2883 ___E,
2884 >(
2885 value, preallocated.encoder, &mut out, 4095
2886 )?;
2887 } else {
2888 ::fidl_next::WireEnvelope::encode_zero(&mut out)
2889 }
2890 }
2891
2892 2 => {
2893 if let Some(value) = self.flags.take() {
2894 ::fidl_next::WireEnvelope::encode_value::<
2895 ::fidl_next_fuchsia_io::wire::Flags,
2896 ___E,
2897 >(
2898 value, preallocated.encoder, &mut out, ()
2899 )?;
2900 } else {
2901 ::fidl_next::WireEnvelope::encode_zero(&mut out)
2902 }
2903 }
2904
2905 1 => {
2906 if let Some(value) = self.channel.take() {
2907 ::fidl_next::WireEnvelope::encode_value::<
2908 ::fidl_next::fuchsia::WireChannel,
2909 ___E,
2910 >(
2911 value, preallocated.encoder, &mut out, ()
2912 )?;
2913 } else {
2914 ::fidl_next::WireEnvelope::encode_zero(&mut out)
2915 }
2916 }
2917
2918 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
2919 }
2920 unsafe {
2921 preallocated.write_next(out.assume_init_ref());
2922 }
2923 }
2924
2925 ::fidl_next::WireTable::encode_len(table, max_ord);
2926
2927 Ok(())
2928 }
2929 }
2930
2931 impl<'de> ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest<'de>>
2932 for DirReceiverReceiveRequest
2933 {
2934 #[inline]
2935 fn from_wire(wire_: crate::wire::DirReceiverReceiveRequest<'de>) -> Self {
2936 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2937
2938 let channel = wire_.table.get(1);
2939
2940 let flags = wire_.table.get(2);
2941
2942 let subdir = wire_.table.get(3);
2943
2944 Self {
2945 channel: channel.map(|envelope| {
2946 ::fidl_next::FromWire::from_wire(unsafe {
2947 envelope.read_unchecked::<::fidl_next::fuchsia::WireChannel>()
2948 })
2949 }),
2950
2951 flags: flags.map(|envelope| {
2952 ::fidl_next::FromWire::from_wire(unsafe {
2953 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
2954 })
2955 }),
2956
2957 subdir: subdir.map(|envelope| {
2958 ::fidl_next::FromWire::from_wire(unsafe {
2959 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
2960 })
2961 }),
2962 }
2963 }
2964 }
2965
2966 #[derive(PartialEq, Debug)]
2967 pub enum DirectoryRouterRouteResponse {
2968 Directory(
2969 ::fidl_next::ClientEnd<
2970 ::fidl_next_fuchsia_io::Directory,
2971 ::fidl_next::fuchsia::zx::Channel,
2972 >,
2973 ),
2974
2975 Unavailable(crate::natural::Unit),
2976 }
2977
2978 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>
2979 for DirectoryRouterRouteResponse
2980 where
2981 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2982 ___E: ::fidl_next::fuchsia::HandleEncoder,
2983 {
2984 #[inline]
2985 fn encode(
2986 self,
2987 encoder: &mut ___E,
2988 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRouterRouteResponse>,
2989 _: (),
2990 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2991 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
2992
2993 match self {
2994 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2995 ___E,
2996 ::fidl_next::ClientEnd<
2997 ::fidl_next_fuchsia_io::Directory,
2998 ::fidl_next::fuchsia::WireChannel,
2999 >,
3000 >(value, 1, encoder, raw, ())?,
3001
3002 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
3003 ___E,
3004 crate::wire::Unit,
3005 >(value, 2, encoder, raw, ())?,
3006 }
3007
3008 Ok(())
3009 }
3010 }
3011
3012 unsafe impl<___E>
3013 ::fidl_next::EncodeOption<crate::wire_optional::DirectoryRouterRouteResponse, ___E>
3014 for DirectoryRouterRouteResponse
3015 where
3016 ___E: ?Sized,
3017 DirectoryRouterRouteResponse:
3018 ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>,
3019 {
3020 #[inline]
3021 fn encode_option(
3022 this: ::core::option::Option<Self>,
3023 encoder: &mut ___E,
3024 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirectoryRouterRouteResponse>,
3025 _: (),
3026 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3027 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3028
3029 if let Some(inner) = this {
3030 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3031 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3032 } else {
3033 ::fidl_next::RawWireUnion::encode_absent(raw);
3034 }
3035
3036 Ok(())
3037 }
3038 }
3039
3040 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
3041 for DirectoryRouterRouteResponse
3042 {
3043 #[inline]
3044 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
3045 let wire = ::core::mem::ManuallyDrop::new(wire);
3046 match wire.raw.ordinal() {
3047 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
3048 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3049 ::fidl_next_fuchsia_io::Directory,
3050 ::fidl_next::fuchsia::WireChannel,
3051 >>()
3052 })),
3053
3054 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3055 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3056 })),
3057
3058 _ => unsafe { ::core::hint::unreachable_unchecked() },
3059 }
3060 }
3061 }
3062
3063 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3064 for DirectoryRouterRouteResponse
3065 {
3066 #[inline]
3067 fn from_wire_option(
3068 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3069 ) -> ::core::option::Option<Self> {
3070 if let Some(inner) = wire.into_option() {
3071 Some(::fidl_next::FromWire::from_wire(inner))
3072 } else {
3073 None
3074 }
3075 }
3076 }
3077
3078 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3079 for Box<DirectoryRouterRouteResponse>
3080 {
3081 #[inline]
3082 fn from_wire_option(
3083 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3084 ) -> ::core::option::Option<Self> {
3085 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
3086 crate::wire_optional::DirectoryRouterRouteResponse,
3087 >>::from_wire_option(wire)
3088 .map(Box::new)
3089 }
3090 }
3091
3092 #[doc = " Contains a protocol open request.\n"]
3093 #[derive(PartialEq, Debug)]
3094 #[repr(C)]
3095 pub struct ProtocolPayload {
3096 pub channel: ::fidl_next::fuchsia::zx::Channel,
3097 }
3098
3099 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E> for ProtocolPayload
3100 where
3101 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3102 ___E: ::fidl_next::fuchsia::HandleEncoder,
3103 {
3104 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
3105 ::fidl_next::CopyOptimization::enable_if(
3106 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
3107 ::fidl_next::fuchsia::WireChannel,
3108 ___E,
3109 >>::COPY_OPTIMIZATION
3110 .is_enabled(),
3111 )
3112 };
3113
3114 #[inline]
3115 fn encode(
3116 self,
3117 encoder_: &mut ___E,
3118 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
3119 _: (),
3120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3121 ::fidl_next::munge! {
3122 let crate::wire::ProtocolPayload {
3123 channel,
3124
3125 } = out_;
3126 }
3127
3128 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3129
3130 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3131
3132 Ok(())
3133 }
3134 }
3135
3136 unsafe impl<___E>
3137 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>, ___E>
3138 for ProtocolPayload
3139 where
3140 ___E: ::fidl_next::Encoder + ?Sized,
3141 ProtocolPayload: ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>,
3142 {
3143 #[inline]
3144 fn encode_option(
3145 this: ::core::option::Option<Self>,
3146 encoder: &mut ___E,
3147 out: &mut ::core::mem::MaybeUninit<
3148 ::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>,
3149 >,
3150 _: (),
3151 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3152 if let Some(inner) = this {
3153 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3154 ::fidl_next::WireBox::encode_present(out);
3155 } else {
3156 ::fidl_next::WireBox::encode_absent(out);
3157 }
3158
3159 Ok(())
3160 }
3161 }
3162
3163 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
3164 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
3165 ::fidl_next::CopyOptimization::enable_if(
3166 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3167 ::fidl_next::fuchsia::WireChannel,
3168 >>::COPY_OPTIMIZATION
3169 .is_enabled(),
3170 )
3171 };
3172
3173 #[inline]
3174 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
3175 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
3176 }
3177 }
3178}
3179
3180pub mod wire {
3181
3182 pub use fidl_next_common_fuchsia_component_sandbox::wire::*;
3183
3184 pub type Token = ::fidl_next::fuchsia::WireEventPair;
3186
3187 #[derive(Debug)]
3189 #[repr(C)]
3190 pub struct DictionaryRef {
3191 pub token: ::fidl_next::fuchsia::WireEventPair,
3192 }
3193
3194 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
3195 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
3196
3197 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
3198
3199 unsafe impl ::fidl_next::Wire for DictionaryRef {
3200 type Owned<'de> = DictionaryRef;
3201
3202 #[inline]
3203 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3204 ::fidl_next::munge! {
3205 let Self {
3206
3207 token,
3208
3209 } = &mut *out_;
3210 }
3211
3212 ::fidl_next::Wire::zero_padding(token);
3213 }
3214 }
3215
3216 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
3217 where
3218 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3219 ___D: ::fidl_next::fuchsia::HandleDecoder,
3220 {
3221 fn decode(
3222 slot_: ::fidl_next::Slot<'_, Self>,
3223 decoder_: &mut ___D,
3224 _: (),
3225 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3226 ::fidl_next::munge! {
3227 let Self {
3228
3229 mut token,
3230
3231 } = slot_;
3232 }
3233
3234 let _field = token.as_mut();
3235
3236 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3237
3238 Ok(())
3239 }
3240 }
3241
3242 impl ::fidl_next::IntoNatural for DictionaryRef {
3243 type Natural = crate::natural::DictionaryRef;
3244 }
3245
3246 impl ::fidl_next::Unconstrained for DictionaryRef {}
3247
3248 #[derive(Debug)]
3250 #[repr(C)]
3251 pub struct Connector {
3252 pub token: ::fidl_next::fuchsia::WireEventPair,
3253 }
3254
3255 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
3256 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
3257
3258 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
3259
3260 unsafe impl ::fidl_next::Wire for Connector {
3261 type Owned<'de> = Connector;
3262
3263 #[inline]
3264 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3265 ::fidl_next::munge! {
3266 let Self {
3267
3268 token,
3269
3270 } = &mut *out_;
3271 }
3272
3273 ::fidl_next::Wire::zero_padding(token);
3274 }
3275 }
3276
3277 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
3278 where
3279 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3280 ___D: ::fidl_next::fuchsia::HandleDecoder,
3281 {
3282 fn decode(
3283 slot_: ::fidl_next::Slot<'_, Self>,
3284 decoder_: &mut ___D,
3285 _: (),
3286 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3287 ::fidl_next::munge! {
3288 let Self {
3289
3290 mut token,
3291
3292 } = slot_;
3293 }
3294
3295 let _field = token.as_mut();
3296
3297 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3298
3299 Ok(())
3300 }
3301 }
3302
3303 impl ::fidl_next::IntoNatural for Connector {
3304 type Natural = crate::natural::Connector;
3305 }
3306
3307 impl ::fidl_next::Unconstrained for Connector {}
3308
3309 #[derive(Debug)]
3311 #[repr(C)]
3312 pub struct DirConnector {
3313 pub token: ::fidl_next::fuchsia::WireEventPair,
3314 }
3315
3316 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
3317 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
3318
3319 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
3320
3321 unsafe impl ::fidl_next::Wire for DirConnector {
3322 type Owned<'de> = DirConnector;
3323
3324 #[inline]
3325 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3326 ::fidl_next::munge! {
3327 let Self {
3328
3329 token,
3330
3331 } = &mut *out_;
3332 }
3333
3334 ::fidl_next::Wire::zero_padding(token);
3335 }
3336 }
3337
3338 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
3339 where
3340 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3341 ___D: ::fidl_next::fuchsia::HandleDecoder,
3342 {
3343 fn decode(
3344 slot_: ::fidl_next::Slot<'_, Self>,
3345 decoder_: &mut ___D,
3346 _: (),
3347 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3348 ::fidl_next::munge! {
3349 let Self {
3350
3351 mut token,
3352
3353 } = slot_;
3354 }
3355
3356 let _field = token.as_mut();
3357
3358 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3359
3360 Ok(())
3361 }
3362 }
3363
3364 impl ::fidl_next::IntoNatural for DirConnector {
3365 type Natural = crate::natural::DirConnector;
3366 }
3367
3368 impl ::fidl_next::Unconstrained for DirConnector {}
3369
3370 #[derive(Debug)]
3372 #[repr(C)]
3373 pub struct DirEntry {
3374 pub token: ::fidl_next::fuchsia::WireEventPair,
3375 }
3376
3377 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
3378 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
3379
3380 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
3381
3382 unsafe impl ::fidl_next::Wire for DirEntry {
3383 type Owned<'de> = DirEntry;
3384
3385 #[inline]
3386 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3387 ::fidl_next::munge! {
3388 let Self {
3389
3390 token,
3391
3392 } = &mut *out_;
3393 }
3394
3395 ::fidl_next::Wire::zero_padding(token);
3396 }
3397 }
3398
3399 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
3400 where
3401 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3402 ___D: ::fidl_next::fuchsia::HandleDecoder,
3403 {
3404 fn decode(
3405 slot_: ::fidl_next::Slot<'_, Self>,
3406 decoder_: &mut ___D,
3407 _: (),
3408 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3409 ::fidl_next::munge! {
3410 let Self {
3411
3412 mut token,
3413
3414 } = slot_;
3415 }
3416
3417 let _field = token.as_mut();
3418
3419 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3420
3421 Ok(())
3422 }
3423 }
3424
3425 impl ::fidl_next::IntoNatural for DirEntry {
3426 type Natural = crate::natural::DirEntry;
3427 }
3428
3429 impl ::fidl_next::Unconstrained for DirEntry {}
3430
3431 #[repr(transparent)]
3433 pub struct Capability<'de> {
3434 pub(crate) raw: ::fidl_next::RawWireUnion,
3435 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3436 }
3437
3438 impl<'de> Drop for Capability<'de> {
3439 fn drop(&mut self) {
3440 match self.raw.ordinal() {
3441 1 => {
3442 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
3443 }
3444
3445 2 => {
3446 let _ = unsafe {
3447 self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
3448 };
3449 }
3450
3451 3 => {
3452 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
3453 }
3454
3455 4 => {
3456 let _ =
3457 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
3458 }
3459
3460 5 => {
3461 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
3462 }
3463
3464 6 => {
3465 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
3466 }
3467
3468 7 => {
3469 let _ = unsafe {
3470 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3471 ::fidl_next_fuchsia_io::Directory,
3472 ::fidl_next::fuchsia::WireChannel,
3473 >>()
3474 };
3475 }
3476
3477 8 => {
3478 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
3479 }
3480
3481 9 => {
3482 let _ = unsafe {
3483 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3484 crate::ConnectorRouter,
3485 ::fidl_next::fuchsia::WireChannel,
3486 >>()
3487 };
3488 }
3489
3490 10 => {
3491 let _ = unsafe {
3492 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3493 crate::DictionaryRouter,
3494 ::fidl_next::fuchsia::WireChannel,
3495 >>()
3496 };
3497 }
3498
3499 11 => {
3500 let _ = unsafe {
3501 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3502 crate::DirEntryRouter,
3503 ::fidl_next::fuchsia::WireChannel,
3504 >>()
3505 };
3506 }
3507
3508 12 => {
3509 let _ = unsafe {
3510 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3511 crate::DataRouter,
3512 ::fidl_next::fuchsia::WireChannel,
3513 >>()
3514 };
3515 }
3516
3517 13 => {
3518 let _ = unsafe {
3519 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3520 crate::DirConnectorRouter,
3521 ::fidl_next::fuchsia::WireChannel,
3522 >>()
3523 };
3524 }
3525
3526 _ => (),
3527 }
3528 }
3529 }
3530
3531 unsafe impl ::fidl_next::Wire for Capability<'static> {
3532 type Owned<'de> = Capability<'de>;
3533
3534 #[inline]
3535 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3536 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3537 ::fidl_next::RawWireUnion::zero_padding(raw);
3538 }
3539 }
3540
3541 pub mod capability {
3542 pub enum Ref<'de> {
3543 Unit(&'de crate::wire::Unit),
3544
3545 Handle(&'de ::fidl_next::fuchsia::WireNullableHandle),
3546
3547 Data(&'de crate::wire::Data<'de>),
3548
3549 Dictionary(&'de crate::wire::DictionaryRef),
3550
3551 Connector(&'de crate::wire::Connector),
3552
3553 DirConnector(&'de crate::wire::DirConnector),
3554
3555 Directory(
3556 &'de ::fidl_next::ClientEnd<
3557 ::fidl_next_fuchsia_io::Directory,
3558 ::fidl_next::fuchsia::WireChannel,
3559 >,
3560 ),
3561
3562 DirEntry(&'de crate::wire::DirEntry),
3563
3564 ConnectorRouter(
3565 &'de ::fidl_next::ClientEnd<
3566 crate::ConnectorRouter,
3567 ::fidl_next::fuchsia::WireChannel,
3568 >,
3569 ),
3570
3571 DictionaryRouter(
3572 &'de ::fidl_next::ClientEnd<
3573 crate::DictionaryRouter,
3574 ::fidl_next::fuchsia::WireChannel,
3575 >,
3576 ),
3577
3578 DirEntryRouter(
3579 &'de ::fidl_next::ClientEnd<
3580 crate::DirEntryRouter,
3581 ::fidl_next::fuchsia::WireChannel,
3582 >,
3583 ),
3584
3585 DataRouter(
3586 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
3587 ),
3588
3589 DirConnectorRouter(
3590 &'de ::fidl_next::ClientEnd<
3591 crate::DirConnectorRouter,
3592 ::fidl_next::fuchsia::WireChannel,
3593 >,
3594 ),
3595
3596 UnknownOrdinal_(u64),
3597 }
3598 }
3599
3600 impl<'de> Capability<'de> {
3601 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
3602 match self.raw.ordinal() {
3603 1 => crate::wire::capability::Ref::Unit(unsafe {
3604 self.raw.get().deref_unchecked::<crate::wire::Unit>()
3605 }),
3606
3607 2 => crate::wire::capability::Ref::Handle(unsafe {
3608 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
3609 }),
3610
3611 3 => crate::wire::capability::Ref::Data(unsafe {
3612 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
3613 }),
3614
3615 4 => crate::wire::capability::Ref::Dictionary(unsafe {
3616 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
3617 }),
3618
3619 5 => crate::wire::capability::Ref::Connector(unsafe {
3620 self.raw.get().deref_unchecked::<crate::wire::Connector>()
3621 }),
3622
3623 6 => crate::wire::capability::Ref::DirConnector(unsafe {
3624 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
3625 }),
3626
3627 7 => crate::wire::capability::Ref::Directory(unsafe {
3628 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3629 ::fidl_next_fuchsia_io::Directory,
3630 ::fidl_next::fuchsia::WireChannel,
3631 >>()
3632 }),
3633
3634 8 => crate::wire::capability::Ref::DirEntry(unsafe {
3635 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
3636 }),
3637
3638 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
3639 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3640 crate::ConnectorRouter,
3641 ::fidl_next::fuchsia::WireChannel,
3642 >>()
3643 }),
3644
3645 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
3646 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3647 crate::DictionaryRouter,
3648 ::fidl_next::fuchsia::WireChannel,
3649 >>()
3650 }),
3651
3652 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
3653 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3654 crate::DirEntryRouter,
3655 ::fidl_next::fuchsia::WireChannel,
3656 >>()
3657 }),
3658
3659 12 => crate::wire::capability::Ref::DataRouter(unsafe {
3660 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
3661 }),
3662
3663 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
3664 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
3665 crate::DirConnectorRouter,
3666 ::fidl_next::fuchsia::WireChannel,
3667 >>()
3668 }),
3669
3670 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
3671 }
3672 }
3673 }
3674
3675 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
3676 where
3677 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3678 ___D: ::fidl_next::Decoder,
3679 ___D: ::fidl_next::fuchsia::HandleDecoder,
3680 {
3681 fn decode(
3682 mut slot: ::fidl_next::Slot<'_, Self>,
3683 decoder: &mut ___D,
3684 _: (),
3685 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3686 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3687 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
3688 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
3689 raw,
3690 decoder,
3691 (),
3692 )?,
3693
3694 2 => ::fidl_next::RawWireUnion::decode_as::<
3695 ___D,
3696 ::fidl_next::fuchsia::WireNullableHandle,
3697 >(raw, decoder, ())?,
3698
3699 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
3700 raw,
3701 decoder,
3702 (),
3703 )?,
3704
3705 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
3706 raw,
3707 decoder,
3708 (),
3709 )?,
3710
3711 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
3712 raw,
3713 decoder,
3714 (),
3715 )?,
3716
3717 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
3718 raw,
3719 decoder,
3720 (),
3721 )?,
3722
3723 7 => ::fidl_next::RawWireUnion::decode_as::<
3724 ___D,
3725 ::fidl_next::ClientEnd<
3726 ::fidl_next_fuchsia_io::Directory,
3727 ::fidl_next::fuchsia::WireChannel,
3728 >,
3729 >(raw, decoder, ())?,
3730
3731 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
3732 raw,
3733 decoder,
3734 (),
3735 )?,
3736
3737 9 => ::fidl_next::RawWireUnion::decode_as::<
3738 ___D,
3739 ::fidl_next::ClientEnd<
3740 crate::ConnectorRouter,
3741 ::fidl_next::fuchsia::WireChannel,
3742 >,
3743 >(raw, decoder, ())?,
3744
3745 10 => ::fidl_next::RawWireUnion::decode_as::<
3746 ___D,
3747 ::fidl_next::ClientEnd<
3748 crate::DictionaryRouter,
3749 ::fidl_next::fuchsia::WireChannel,
3750 >,
3751 >(raw, decoder, ())?,
3752
3753 11 => ::fidl_next::RawWireUnion::decode_as::<
3754 ___D,
3755 ::fidl_next::ClientEnd<
3756 crate::DirEntryRouter,
3757 ::fidl_next::fuchsia::WireChannel,
3758 >,
3759 >(raw, decoder, ())?,
3760
3761 12 => ::fidl_next::RawWireUnion::decode_as::<
3762 ___D,
3763 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
3764 >(raw, decoder, ())?,
3765
3766 13 => ::fidl_next::RawWireUnion::decode_as::<
3767 ___D,
3768 ::fidl_next::ClientEnd<
3769 crate::DirConnectorRouter,
3770 ::fidl_next::fuchsia::WireChannel,
3771 >,
3772 >(raw, decoder, ())?,
3773
3774 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
3775 }
3776
3777 Ok(())
3778 }
3779 }
3780
3781 impl<'de> ::core::fmt::Debug for Capability<'de> {
3782 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3783 match self.raw.ordinal() {
3784 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
3785 2 => unsafe {
3786 self.raw
3787 .get()
3788 .deref_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
3789 .fmt(f)
3790 },
3791 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
3792 4 => unsafe {
3793 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
3794 },
3795 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
3796 6 => unsafe {
3797 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
3798 },
3799 7 => unsafe {
3800 self.raw
3801 .get()
3802 .deref_unchecked::<::fidl_next::ClientEnd<
3803 ::fidl_next_fuchsia_io::Directory,
3804 ::fidl_next::fuchsia::WireChannel,
3805 >>()
3806 .fmt(f)
3807 },
3808 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
3809 9 => unsafe {
3810 self.raw
3811 .get()
3812 .deref_unchecked::<::fidl_next::ClientEnd<
3813 crate::ConnectorRouter,
3814 ::fidl_next::fuchsia::WireChannel,
3815 >>()
3816 .fmt(f)
3817 },
3818 10 => unsafe {
3819 self.raw
3820 .get()
3821 .deref_unchecked::<::fidl_next::ClientEnd<
3822 crate::DictionaryRouter,
3823 ::fidl_next::fuchsia::WireChannel,
3824 >>()
3825 .fmt(f)
3826 },
3827 11 => unsafe {
3828 self.raw
3829 .get()
3830 .deref_unchecked::<::fidl_next::ClientEnd<
3831 crate::DirEntryRouter,
3832 ::fidl_next::fuchsia::WireChannel,
3833 >>()
3834 .fmt(f)
3835 },
3836 12 => unsafe {
3837 self.raw.get().deref_unchecked::<
3838 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
3839 >().fmt(f)
3840 },
3841 13 => unsafe {
3842 self.raw
3843 .get()
3844 .deref_unchecked::<::fidl_next::ClientEnd<
3845 crate::DirConnectorRouter,
3846 ::fidl_next::fuchsia::WireChannel,
3847 >>()
3848 .fmt(f)
3849 },
3850 _ => unsafe { ::core::hint::unreachable_unchecked() },
3851 }
3852 }
3853 }
3854
3855 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
3856 type Natural = crate::natural::Capability;
3857 }
3858
3859 impl ::fidl_next::Unconstrained for Capability<'static> {}
3860
3861 #[derive(Debug)]
3863 #[repr(C)]
3864 pub struct CapabilityStoreConnectorCreateRequest {
3865 pub id: ::fidl_next::WireU64,
3866
3867 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
3868 }
3869
3870 static_assertions::const_assert_eq!(
3871 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
3872 16
3873 );
3874 static_assertions::const_assert_eq!(
3875 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
3876 8
3877 );
3878
3879 static_assertions::const_assert_eq!(
3880 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
3881 0
3882 );
3883
3884 static_assertions::const_assert_eq!(
3885 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
3886 8
3887 );
3888
3889 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
3890 type Owned<'de> = CapabilityStoreConnectorCreateRequest;
3891
3892 #[inline]
3893 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3894 ::fidl_next::munge! {
3895 let Self {
3896
3897 id,
3898 receiver,
3899
3900 } = &mut *out_;
3901 }
3902
3903 ::fidl_next::Wire::zero_padding(id);
3904
3905 ::fidl_next::Wire::zero_padding(receiver);
3906
3907 unsafe {
3908 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3909 }
3910 }
3911 }
3912
3913 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
3914 where
3915 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3916 ___D: ::fidl_next::fuchsia::HandleDecoder,
3917 {
3918 fn decode(
3919 slot_: ::fidl_next::Slot<'_, Self>,
3920 decoder_: &mut ___D,
3921 _: (),
3922 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3923 if slot_.as_bytes()[12..16] != [0u8; 4] {
3924 return Err(::fidl_next::DecodeError::InvalidPadding);
3925 }
3926
3927 ::fidl_next::munge! {
3928 let Self {
3929
3930 mut id,
3931 mut receiver,
3932
3933 } = slot_;
3934 }
3935
3936 let _field = id.as_mut();
3937
3938 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3939
3940 let _field = receiver.as_mut();
3941
3942 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
3943
3944 Ok(())
3945 }
3946 }
3947
3948 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
3949 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
3950 }
3951
3952 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateRequest {}
3953
3954 #[derive(Debug)]
3956 #[repr(C)]
3957 pub struct CapabilityStoreConnectorOpenRequest {
3958 pub id: ::fidl_next::WireU64,
3959
3960 pub server_end: ::fidl_next::fuchsia::WireChannel,
3961 }
3962
3963 static_assertions::const_assert_eq!(
3964 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
3965 16
3966 );
3967 static_assertions::const_assert_eq!(
3968 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
3969 8
3970 );
3971
3972 static_assertions::const_assert_eq!(
3973 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
3974 0
3975 );
3976
3977 static_assertions::const_assert_eq!(
3978 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
3979 8
3980 );
3981
3982 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
3983 type Owned<'de> = CapabilityStoreConnectorOpenRequest;
3984
3985 #[inline]
3986 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3987 ::fidl_next::munge! {
3988 let Self {
3989
3990 id,
3991 server_end,
3992
3993 } = &mut *out_;
3994 }
3995
3996 ::fidl_next::Wire::zero_padding(id);
3997
3998 ::fidl_next::Wire::zero_padding(server_end);
3999
4000 unsafe {
4001 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4002 }
4003 }
4004 }
4005
4006 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
4007 where
4008 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4009 ___D: ::fidl_next::fuchsia::HandleDecoder,
4010 {
4011 fn decode(
4012 slot_: ::fidl_next::Slot<'_, Self>,
4013 decoder_: &mut ___D,
4014 _: (),
4015 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4016 if slot_.as_bytes()[12..16] != [0u8; 4] {
4017 return Err(::fidl_next::DecodeError::InvalidPadding);
4018 }
4019
4020 ::fidl_next::munge! {
4021 let Self {
4022
4023 mut id,
4024 mut server_end,
4025
4026 } = slot_;
4027 }
4028
4029 let _field = id.as_mut();
4030
4031 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4032
4033 let _field = server_end.as_mut();
4034
4035 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4036
4037 Ok(())
4038 }
4039 }
4040
4041 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
4042 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
4043 }
4044
4045 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenRequest {}
4046
4047 #[derive(Debug)]
4049 #[repr(C)]
4050 pub struct CapabilityStoreDirConnectorCreateRequest {
4051 pub id: ::fidl_next::WireU64,
4052
4053 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
4054 }
4055
4056 static_assertions::const_assert_eq!(
4057 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
4058 16
4059 );
4060 static_assertions::const_assert_eq!(
4061 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
4062 8
4063 );
4064
4065 static_assertions::const_assert_eq!(
4066 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
4067 0
4068 );
4069
4070 static_assertions::const_assert_eq!(
4071 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
4072 8
4073 );
4074
4075 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
4076 type Owned<'de> = CapabilityStoreDirConnectorCreateRequest;
4077
4078 #[inline]
4079 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4080 ::fidl_next::munge! {
4081 let Self {
4082
4083 id,
4084 receiver,
4085
4086 } = &mut *out_;
4087 }
4088
4089 ::fidl_next::Wire::zero_padding(id);
4090
4091 ::fidl_next::Wire::zero_padding(receiver);
4092
4093 unsafe {
4094 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4095 }
4096 }
4097 }
4098
4099 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
4100 where
4101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4102 ___D: ::fidl_next::fuchsia::HandleDecoder,
4103 {
4104 fn decode(
4105 slot_: ::fidl_next::Slot<'_, Self>,
4106 decoder_: &mut ___D,
4107 _: (),
4108 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4109 if slot_.as_bytes()[12..16] != [0u8; 4] {
4110 return Err(::fidl_next::DecodeError::InvalidPadding);
4111 }
4112
4113 ::fidl_next::munge! {
4114 let Self {
4115
4116 mut id,
4117 mut receiver,
4118
4119 } = slot_;
4120 }
4121
4122 let _field = id.as_mut();
4123
4124 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4125
4126 let _field = receiver.as_mut();
4127
4128 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4129
4130 Ok(())
4131 }
4132 }
4133
4134 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
4135 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
4136 }
4137
4138 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateRequest {}
4139
4140 #[derive(Debug)]
4142 #[repr(C)]
4143 pub struct CapabilityStoreDictionaryLegacyImportRequest {
4144 pub id: ::fidl_next::WireU64,
4145
4146 pub client_end: ::fidl_next::fuchsia::WireChannel,
4147 }
4148
4149 static_assertions::const_assert_eq!(
4150 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4151 16
4152 );
4153 static_assertions::const_assert_eq!(
4154 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4155 8
4156 );
4157
4158 static_assertions::const_assert_eq!(
4159 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
4160 0
4161 );
4162
4163 static_assertions::const_assert_eq!(
4164 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
4165 8
4166 );
4167
4168 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
4169 type Owned<'de> = CapabilityStoreDictionaryLegacyImportRequest;
4170
4171 #[inline]
4172 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4173 ::fidl_next::munge! {
4174 let Self {
4175
4176 id,
4177 client_end,
4178
4179 } = &mut *out_;
4180 }
4181
4182 ::fidl_next::Wire::zero_padding(id);
4183
4184 ::fidl_next::Wire::zero_padding(client_end);
4185
4186 unsafe {
4187 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4188 }
4189 }
4190 }
4191
4192 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
4193 where
4194 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4195 ___D: ::fidl_next::fuchsia::HandleDecoder,
4196 {
4197 fn decode(
4198 slot_: ::fidl_next::Slot<'_, Self>,
4199 decoder_: &mut ___D,
4200 _: (),
4201 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4202 if slot_.as_bytes()[12..16] != [0u8; 4] {
4203 return Err(::fidl_next::DecodeError::InvalidPadding);
4204 }
4205
4206 ::fidl_next::munge! {
4207 let Self {
4208
4209 mut id,
4210 mut client_end,
4211
4212 } = slot_;
4213 }
4214
4215 let _field = id.as_mut();
4216
4217 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4218
4219 let _field = client_end.as_mut();
4220
4221 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
4222
4223 Ok(())
4224 }
4225 }
4226
4227 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
4228 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
4229 }
4230
4231 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportRequest {}
4232
4233 #[derive(Debug)]
4235 #[repr(C)]
4236 pub struct CapabilityStoreDictionaryLegacyExportRequest {
4237 pub id: ::fidl_next::WireU64,
4238
4239 pub server_end: ::fidl_next::fuchsia::WireChannel,
4240 }
4241
4242 static_assertions::const_assert_eq!(
4243 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4244 16
4245 );
4246 static_assertions::const_assert_eq!(
4247 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4248 8
4249 );
4250
4251 static_assertions::const_assert_eq!(
4252 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
4253 0
4254 );
4255
4256 static_assertions::const_assert_eq!(
4257 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
4258 8
4259 );
4260
4261 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
4262 type Owned<'de> = CapabilityStoreDictionaryLegacyExportRequest;
4263
4264 #[inline]
4265 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4266 ::fidl_next::munge! {
4267 let Self {
4268
4269 id,
4270 server_end,
4271
4272 } = &mut *out_;
4273 }
4274
4275 ::fidl_next::Wire::zero_padding(id);
4276
4277 ::fidl_next::Wire::zero_padding(server_end);
4278
4279 unsafe {
4280 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4281 }
4282 }
4283 }
4284
4285 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
4286 where
4287 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4288 ___D: ::fidl_next::fuchsia::HandleDecoder,
4289 {
4290 fn decode(
4291 slot_: ::fidl_next::Slot<'_, Self>,
4292 decoder_: &mut ___D,
4293 _: (),
4294 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4295 if slot_.as_bytes()[12..16] != [0u8; 4] {
4296 return Err(::fidl_next::DecodeError::InvalidPadding);
4297 }
4298
4299 ::fidl_next::munge! {
4300 let Self {
4301
4302 mut id,
4303 mut server_end,
4304
4305 } = slot_;
4306 }
4307
4308 let _field = id.as_mut();
4309
4310 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4311
4312 let _field = server_end.as_mut();
4313
4314 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4315
4316 Ok(())
4317 }
4318 }
4319
4320 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
4321 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
4322 }
4323
4324 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportRequest {}
4325
4326 #[derive(Debug)]
4328 #[repr(C)]
4329 pub struct CapabilityStoreDictionaryKeysRequest {
4330 pub id: ::fidl_next::WireU64,
4331
4332 pub iterator: ::fidl_next::ServerEnd<
4333 crate::DictionaryKeysIterator,
4334 ::fidl_next::fuchsia::WireChannel,
4335 >,
4336 }
4337
4338 static_assertions::const_assert_eq!(
4339 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
4340 16
4341 );
4342 static_assertions::const_assert_eq!(
4343 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
4344 8
4345 );
4346
4347 static_assertions::const_assert_eq!(
4348 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
4349 0
4350 );
4351
4352 static_assertions::const_assert_eq!(
4353 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
4354 8
4355 );
4356
4357 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
4358 type Owned<'de> = CapabilityStoreDictionaryKeysRequest;
4359
4360 #[inline]
4361 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4362 ::fidl_next::munge! {
4363 let Self {
4364
4365 id,
4366 iterator,
4367
4368 } = &mut *out_;
4369 }
4370
4371 ::fidl_next::Wire::zero_padding(id);
4372
4373 ::fidl_next::Wire::zero_padding(iterator);
4374
4375 unsafe {
4376 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4377 }
4378 }
4379 }
4380
4381 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
4382 where
4383 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4384 ___D: ::fidl_next::fuchsia::HandleDecoder,
4385 {
4386 fn decode(
4387 slot_: ::fidl_next::Slot<'_, Self>,
4388 decoder_: &mut ___D,
4389 _: (),
4390 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4391 if slot_.as_bytes()[12..16] != [0u8; 4] {
4392 return Err(::fidl_next::DecodeError::InvalidPadding);
4393 }
4394
4395 ::fidl_next::munge! {
4396 let Self {
4397
4398 mut id,
4399 mut iterator,
4400
4401 } = slot_;
4402 }
4403
4404 let _field = id.as_mut();
4405
4406 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4407
4408 let _field = iterator.as_mut();
4409
4410 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4411
4412 Ok(())
4413 }
4414 }
4415
4416 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
4417 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
4418 }
4419
4420 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysRequest {}
4421
4422 #[derive(Debug)]
4424 #[repr(C)]
4425 pub struct CapabilityStoreDictionaryEnumerateRequest {
4426 pub id: ::fidl_next::WireU64,
4427
4428 pub iterator: ::fidl_next::ServerEnd<
4429 crate::DictionaryEnumerateIterator,
4430 ::fidl_next::fuchsia::WireChannel,
4431 >,
4432 }
4433
4434 static_assertions::const_assert_eq!(
4435 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4436 16
4437 );
4438 static_assertions::const_assert_eq!(
4439 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4440 8
4441 );
4442
4443 static_assertions::const_assert_eq!(
4444 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
4445 0
4446 );
4447
4448 static_assertions::const_assert_eq!(
4449 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
4450 8
4451 );
4452
4453 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
4454 type Owned<'de> = CapabilityStoreDictionaryEnumerateRequest;
4455
4456 #[inline]
4457 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4458 ::fidl_next::munge! {
4459 let Self {
4460
4461 id,
4462 iterator,
4463
4464 } = &mut *out_;
4465 }
4466
4467 ::fidl_next::Wire::zero_padding(id);
4468
4469 ::fidl_next::Wire::zero_padding(iterator);
4470
4471 unsafe {
4472 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4473 }
4474 }
4475 }
4476
4477 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
4478 where
4479 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4480 ___D: ::fidl_next::fuchsia::HandleDecoder,
4481 {
4482 fn decode(
4483 slot_: ::fidl_next::Slot<'_, Self>,
4484 decoder_: &mut ___D,
4485 _: (),
4486 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4487 if slot_.as_bytes()[12..16] != [0u8; 4] {
4488 return Err(::fidl_next::DecodeError::InvalidPadding);
4489 }
4490
4491 ::fidl_next::munge! {
4492 let Self {
4493
4494 mut id,
4495 mut iterator,
4496
4497 } = slot_;
4498 }
4499
4500 let _field = id.as_mut();
4501
4502 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4503
4504 let _field = iterator.as_mut();
4505
4506 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4507
4508 Ok(())
4509 }
4510 }
4511
4512 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
4513 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
4514 }
4515
4516 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateRequest {}
4517
4518 #[derive(Debug)]
4520 #[repr(C)]
4521 pub struct CapabilityStoreDictionaryDrainRequest {
4522 pub id: ::fidl_next::WireU64,
4523
4524 pub iterator: ::fidl_next::ServerEnd<
4525 crate::DictionaryDrainIterator,
4526 ::fidl_next::fuchsia::WireOptionalChannel,
4527 >,
4528 }
4529
4530 static_assertions::const_assert_eq!(
4531 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
4532 16
4533 );
4534 static_assertions::const_assert_eq!(
4535 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
4536 8
4537 );
4538
4539 static_assertions::const_assert_eq!(
4540 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
4541 0
4542 );
4543
4544 static_assertions::const_assert_eq!(
4545 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
4546 8
4547 );
4548
4549 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
4550 type Owned<'de> = CapabilityStoreDictionaryDrainRequest;
4551
4552 #[inline]
4553 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4554 ::fidl_next::munge! {
4555 let Self {
4556
4557 id,
4558 iterator,
4559
4560 } = &mut *out_;
4561 }
4562
4563 ::fidl_next::Wire::zero_padding(id);
4564
4565 ::fidl_next::Wire::zero_padding(iterator);
4566
4567 unsafe {
4568 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4569 }
4570 }
4571 }
4572
4573 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
4574 where
4575 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4576 ___D: ::fidl_next::fuchsia::HandleDecoder,
4577 {
4578 fn decode(
4579 slot_: ::fidl_next::Slot<'_, Self>,
4580 decoder_: &mut ___D,
4581 _: (),
4582 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4583 if slot_.as_bytes()[12..16] != [0u8; 4] {
4584 return Err(::fidl_next::DecodeError::InvalidPadding);
4585 }
4586
4587 ::fidl_next::munge! {
4588 let Self {
4589
4590 mut id,
4591 mut iterator,
4592
4593 } = slot_;
4594 }
4595
4596 let _field = id.as_mut();
4597
4598 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4599
4600 let _field = iterator.as_mut();
4601
4602 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4603
4604 Ok(())
4605 }
4606 }
4607
4608 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
4609 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
4610 }
4611
4612 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainRequest {}
4613
4614 #[derive(Debug)]
4616 #[repr(C)]
4617 pub struct CapabilityStoreExportResponse<'de> {
4618 pub capability: crate::wire::Capability<'de>,
4619 }
4620
4621 static_assertions::const_assert_eq!(
4622 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
4623 16
4624 );
4625 static_assertions::const_assert_eq!(
4626 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
4627 8
4628 );
4629
4630 static_assertions::const_assert_eq!(
4631 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
4632 0
4633 );
4634
4635 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
4636 type Owned<'de> = CapabilityStoreExportResponse<'de>;
4637
4638 #[inline]
4639 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4640 ::fidl_next::munge! {
4641 let Self {
4642
4643 capability,
4644
4645 } = &mut *out_;
4646 }
4647
4648 ::fidl_next::Wire::zero_padding(capability);
4649 }
4650 }
4651
4652 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'static>
4653 where
4654 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4655 ___D: ::fidl_next::Decoder,
4656 ___D: ::fidl_next::fuchsia::HandleDecoder,
4657 {
4658 fn decode(
4659 slot_: ::fidl_next::Slot<'_, Self>,
4660 decoder_: &mut ___D,
4661 _: (),
4662 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4663 ::fidl_next::munge! {
4664 let Self {
4665
4666 mut capability,
4667
4668 } = slot_;
4669 }
4670
4671 let _field = capability.as_mut();
4672
4673 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
4674
4675 Ok(())
4676 }
4677 }
4678
4679 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
4680 type Natural = crate::natural::CapabilityStoreExportResponse;
4681 }
4682
4683 impl ::fidl_next::Unconstrained for CapabilityStoreExportResponse<'static> {}
4684
4685 #[derive(Debug)]
4687 #[repr(C)]
4688 pub struct CapabilityStoreImportRequest<'de> {
4689 pub id: ::fidl_next::WireU64,
4690
4691 pub capability: crate::wire::Capability<'de>,
4692 }
4693
4694 static_assertions::const_assert_eq!(
4695 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
4696 24
4697 );
4698 static_assertions::const_assert_eq!(
4699 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
4700 8
4701 );
4702
4703 static_assertions::const_assert_eq!(
4704 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
4705 0
4706 );
4707
4708 static_assertions::const_assert_eq!(
4709 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
4710 8
4711 );
4712
4713 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
4714 type Owned<'de> = CapabilityStoreImportRequest<'de>;
4715
4716 #[inline]
4717 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4718 ::fidl_next::munge! {
4719 let Self {
4720
4721 id,
4722 capability,
4723
4724 } = &mut *out_;
4725 }
4726
4727 ::fidl_next::Wire::zero_padding(id);
4728
4729 ::fidl_next::Wire::zero_padding(capability);
4730 }
4731 }
4732
4733 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'static>
4734 where
4735 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4736 ___D: ::fidl_next::Decoder,
4737 ___D: ::fidl_next::fuchsia::HandleDecoder,
4738 {
4739 fn decode(
4740 slot_: ::fidl_next::Slot<'_, Self>,
4741 decoder_: &mut ___D,
4742 _: (),
4743 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4744 ::fidl_next::munge! {
4745 let Self {
4746
4747 mut id,
4748 mut capability,
4749
4750 } = slot_;
4751 }
4752
4753 let _field = id.as_mut();
4754
4755 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4756
4757 let _field = capability.as_mut();
4758
4759 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
4760
4761 Ok(())
4762 }
4763 }
4764
4765 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
4766 type Natural = crate::natural::CapabilityStoreImportRequest;
4767 }
4768
4769 impl ::fidl_next::Unconstrained for CapabilityStoreImportRequest<'static> {}
4770
4771 #[repr(C)]
4773 pub struct CapabilityStoreDirConnectorOpenRequest<'de> {
4774 pub(crate) table: ::fidl_next::WireTable<'de>,
4775 }
4776
4777 impl<'de> Drop for CapabilityStoreDirConnectorOpenRequest<'de> {
4778 fn drop(&mut self) {
4779 let _ = self
4780 .table
4781 .get(1)
4782 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });
4783
4784 let _ = self.table.get(2).map(|envelope| unsafe {
4785 envelope.read_unchecked::<::fidl_next::ServerEnd<
4786 ::fidl_next_fuchsia_io::Directory,
4787 ::fidl_next::fuchsia::WireChannel,
4788 >>()
4789 });
4790
4791 let _ = self.table.get(3).map(|envelope| unsafe {
4792 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
4793 });
4794
4795 let _ = self.table.get(4).map(|envelope| unsafe {
4796 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
4797 });
4798 }
4799 }
4800
4801 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest<'static> {
4802 type Owned<'de> = CapabilityStoreDirConnectorOpenRequest<'de>;
4803
4804 #[inline]
4805 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4806 ::fidl_next::munge!(let Self { table } = out);
4807 ::fidl_next::WireTable::zero_padding(table);
4808 }
4809 }
4810
4811 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest<'static>
4812 where
4813 ___D: ::fidl_next::Decoder + ?Sized,
4814 ___D: ::fidl_next::fuchsia::HandleDecoder,
4815 {
4816 fn decode(
4817 slot: ::fidl_next::Slot<'_, Self>,
4818 decoder: &mut ___D,
4819 _: (),
4820 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4821 ::fidl_next::munge!(let Self { table } = slot);
4822
4823 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4824 match ordinal {
4825 0 => unsafe { ::core::hint::unreachable_unchecked() },
4826
4827 1 => {
4828 ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
4829 slot.as_mut(),
4830 decoder,
4831 (),
4832 )?;
4833
4834 Ok(())
4835 }
4836
4837 2 => {
4838 ::fidl_next::WireEnvelope::decode_as::<
4839 ___D,
4840 ::fidl_next::ServerEnd<
4841 ::fidl_next_fuchsia_io::Directory,
4842 ::fidl_next::fuchsia::WireChannel,
4843 >,
4844 >(slot.as_mut(), decoder, ())?;
4845
4846 Ok(())
4847 }
4848
4849 3 => {
4850 ::fidl_next::WireEnvelope::decode_as::<
4851 ___D,
4852 ::fidl_next_fuchsia_io::wire::Flags,
4853 >(slot.as_mut(), decoder, ())?;
4854
4855 Ok(())
4856 }
4857
4858 4 => {
4859 ::fidl_next::WireEnvelope::decode_as::<
4860 ___D,
4861 ::fidl_next::WireString<'static>,
4862 >(slot.as_mut(), decoder, 4095)?;
4863
4864 let value = unsafe {
4865 slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
4866 };
4867
4868 if value.len() > 4095 {
4869 return Err(::fidl_next::DecodeError::VectorTooLong {
4870 size: value.len() as u64,
4871 limit: 4095,
4872 });
4873 }
4874
4875 Ok(())
4876 }
4877
4878 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
4879 }
4880 })
4881 }
4882 }
4883
4884 impl<'de> CapabilityStoreDirConnectorOpenRequest<'de> {
4885 pub fn id(&self) -> ::core::option::Option<&::fidl_next::WireU64> {
4886 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4887 }
4888
4889 pub fn server_end(
4890 &self,
4891 ) -> ::core::option::Option<
4892 &::fidl_next::ServerEnd<
4893 ::fidl_next_fuchsia_io::Directory,
4894 ::fidl_next::fuchsia::WireChannel,
4895 >,
4896 > {
4897 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4898 }
4899
4900 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
4901 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4902 }
4903
4904 pub fn path(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
4905 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4906 }
4907 }
4908
4909 impl<'de> ::core::fmt::Debug for CapabilityStoreDirConnectorOpenRequest<'de> {
4910 fn fmt(
4911 &self,
4912 f: &mut ::core::fmt::Formatter<'_>,
4913 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4914 f.debug_struct("CapabilityStoreDirConnectorOpenRequest")
4915 .field("id", &self.id())
4916 .field("server_end", &self.server_end())
4917 .field("flags", &self.flags())
4918 .field("path", &self.path())
4919 .finish()
4920 }
4921 }
4922
4923 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest<'de> {
4924 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
4925 }
4926
4927 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenRequest<'_> {}
4928
4929 #[derive(Debug)]
4931 #[repr(C)]
4932 pub struct InstanceToken {
4933 pub token: ::fidl_next::fuchsia::WireEventPair,
4934 }
4935
4936 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
4937 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
4938
4939 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
4940
4941 unsafe impl ::fidl_next::Wire for InstanceToken {
4942 type Owned<'de> = InstanceToken;
4943
4944 #[inline]
4945 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4946 ::fidl_next::munge! {
4947 let Self {
4948
4949 token,
4950
4951 } = &mut *out_;
4952 }
4953
4954 ::fidl_next::Wire::zero_padding(token);
4955 }
4956 }
4957
4958 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
4959 where
4960 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4961 ___D: ::fidl_next::fuchsia::HandleDecoder,
4962 {
4963 fn decode(
4964 slot_: ::fidl_next::Slot<'_, Self>,
4965 decoder_: &mut ___D,
4966 _: (),
4967 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4968 ::fidl_next::munge! {
4969 let Self {
4970
4971 mut token,
4972
4973 } = slot_;
4974 }
4975
4976 let _field = token.as_mut();
4977
4978 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
4979
4980 Ok(())
4981 }
4982 }
4983
4984 impl ::fidl_next::IntoNatural for InstanceToken {
4985 type Natural = crate::natural::InstanceToken;
4986 }
4987
4988 impl ::fidl_next::Unconstrained for InstanceToken {}
4989
4990 #[repr(C)]
4992 pub struct RouteRequest<'de> {
4993 pub(crate) table: ::fidl_next::WireTable<'de>,
4994 }
4995
4996 impl<'de> Drop for RouteRequest<'de> {
4997 fn drop(&mut self) {
4998 let _ = self
4999 .table
5000 .get(1)
5001 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
5002
5003 let _ = self
5004 .table
5005 .get(2)
5006 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
5007 }
5008 }
5009
5010 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
5011 type Owned<'de> = RouteRequest<'de>;
5012
5013 #[inline]
5014 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5015 ::fidl_next::munge!(let Self { table } = out);
5016 ::fidl_next::WireTable::zero_padding(table);
5017 }
5018 }
5019
5020 unsafe impl<___D> ::fidl_next::Decode<___D> for RouteRequest<'static>
5021 where
5022 ___D: ::fidl_next::Decoder + ?Sized,
5023 ___D: ::fidl_next::fuchsia::HandleDecoder,
5024 {
5025 fn decode(
5026 slot: ::fidl_next::Slot<'_, Self>,
5027 decoder: &mut ___D,
5028 _: (),
5029 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5030 ::fidl_next::munge!(let Self { table } = slot);
5031
5032 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5033 match ordinal {
5034 0 => unsafe { ::core::hint::unreachable_unchecked() },
5035
5036 1 => {
5037 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::InstanceToken>(
5038 slot.as_mut(),
5039 decoder,
5040 (),
5041 )?;
5042
5043 Ok(())
5044 }
5045
5046 2 => {
5047 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DictionaryRef>(
5048 slot.as_mut(),
5049 decoder,
5050 (),
5051 )?;
5052
5053 Ok(())
5054 }
5055
5056 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
5057 }
5058 })
5059 }
5060 }
5061
5062 impl<'de> RouteRequest<'de> {
5063 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
5064 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5065 }
5066
5067 pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
5068 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5069 }
5070 }
5071
5072 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
5073 fn fmt(
5074 &self,
5075 f: &mut ::core::fmt::Formatter<'_>,
5076 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5077 f.debug_struct("RouteRequest")
5078 .field("requesting", &self.requesting())
5079 .field("metadata", &self.metadata())
5080 .finish()
5081 }
5082 }
5083
5084 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
5085 type Natural = crate::natural::RouteRequest;
5086 }
5087
5088 impl ::fidl_next::Unconstrained for RouteRequest<'_> {}
5089
5090 #[repr(transparent)]
5092 pub struct ConnectorRouterRouteResponse {
5093 pub(crate) raw: ::fidl_next::RawWireUnion,
5094 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5095 }
5096
5097 impl Drop for ConnectorRouterRouteResponse {
5098 fn drop(&mut self) {
5099 match self.raw.ordinal() {
5100 1 => {
5101 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
5102 }
5103
5104 2 => {
5105 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5106 }
5107
5108 _ => unsafe { ::core::hint::unreachable_unchecked() },
5109 }
5110 }
5111 }
5112
5113 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
5114 type Owned<'de> = ConnectorRouterRouteResponse;
5115
5116 #[inline]
5117 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5118 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5119 ::fidl_next::RawWireUnion::zero_padding(raw);
5120 }
5121 }
5122
5123 pub mod connector_router_route_response {
5124 pub enum Ref<'de> {
5125 Connector(&'de crate::wire::Connector),
5126
5127 Unavailable(&'de crate::wire::Unit),
5128 }
5129 }
5130
5131 impl ConnectorRouterRouteResponse {
5132 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
5133 match self.raw.ordinal() {
5134 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
5135 self.raw.get().deref_unchecked::<crate::wire::Connector>()
5136 }),
5137
5138 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
5139 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5140 }),
5141
5142 _ => unsafe { ::core::hint::unreachable_unchecked() },
5143 }
5144 }
5145 }
5146
5147 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
5148 where
5149 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5150 ___D: ::fidl_next::fuchsia::HandleDecoder,
5151 {
5152 fn decode(
5153 mut slot: ::fidl_next::Slot<'_, Self>,
5154 decoder: &mut ___D,
5155 _: (),
5156 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5157 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5158 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5159 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
5160 raw,
5161 decoder,
5162 (),
5163 )?,
5164
5165 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5166 raw,
5167 decoder,
5168 (),
5169 )?,
5170
5171 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5172 }
5173
5174 Ok(())
5175 }
5176 }
5177
5178 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
5179 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5180 match self.raw.ordinal() {
5181 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
5182 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5183 _ => unsafe { ::core::hint::unreachable_unchecked() },
5184 }
5185 }
5186 }
5187
5188 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
5189 type Natural = crate::natural::ConnectorRouterRouteResponse;
5190 }
5191
5192 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
5193
5194 #[repr(transparent)]
5196 pub struct DataRouterRouteResponse<'de> {
5197 pub(crate) raw: ::fidl_next::RawWireUnion,
5198 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
5199 }
5200
5201 impl<'de> Drop for DataRouterRouteResponse<'de> {
5202 fn drop(&mut self) {
5203 match self.raw.ordinal() {
5204 1 => {
5205 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
5206 }
5207
5208 2 => {
5209 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5210 }
5211
5212 _ => unsafe { ::core::hint::unreachable_unchecked() },
5213 }
5214 }
5215 }
5216
5217 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
5218 type Owned<'de> = DataRouterRouteResponse<'de>;
5219
5220 #[inline]
5221 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5222 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5223 ::fidl_next::RawWireUnion::zero_padding(raw);
5224 }
5225 }
5226
5227 pub mod data_router_route_response {
5228 pub enum Ref<'de> {
5229 Data(&'de crate::wire::Data<'de>),
5230
5231 Unavailable(&'de crate::wire::Unit),
5232 }
5233 }
5234
5235 impl<'de> DataRouterRouteResponse<'de> {
5236 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
5237 match self.raw.ordinal() {
5238 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
5239 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
5240 }),
5241
5242 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
5243 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5244 }),
5245
5246 _ => unsafe { ::core::hint::unreachable_unchecked() },
5247 }
5248 }
5249 }
5250
5251 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'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 mut slot: ::fidl_next::Slot<'_, Self>,
5259 decoder: &mut ___D,
5260 _: (),
5261 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5262 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5263 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5264 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
5265 raw,
5266 decoder,
5267 (),
5268 )?,
5269
5270 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
5271 raw,
5272 decoder,
5273 (),
5274 )?,
5275
5276 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5277 }
5278
5279 Ok(())
5280 }
5281 }
5282
5283 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
5284 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5285 match self.raw.ordinal() {
5286 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
5287 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5288 _ => unsafe { ::core::hint::unreachable_unchecked() },
5289 }
5290 }
5291 }
5292
5293 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
5294 type Natural = crate::natural::DataRouterRouteResponse;
5295 }
5296
5297 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
5298
5299 #[derive(Debug)]
5301 #[repr(C)]
5302 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
5303 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryItem<'de>>,
5304
5305 pub end_id: ::fidl_next::WireU64,
5306 }
5307
5308 static_assertions::const_assert_eq!(
5309 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5310 24
5311 );
5312 static_assertions::const_assert_eq!(
5313 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5314 8
5315 );
5316
5317 static_assertions::const_assert_eq!(
5318 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
5319 0
5320 );
5321
5322 static_assertions::const_assert_eq!(
5323 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
5324 16
5325 );
5326
5327 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
5328 type Owned<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
5329
5330 #[inline]
5331 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5332 ::fidl_next::munge! {
5333 let Self {
5334
5335 items,
5336 end_id,
5337
5338 } = &mut *out_;
5339 }
5340
5341 ::fidl_next::Wire::zero_padding(items);
5342
5343 ::fidl_next::Wire::zero_padding(end_id);
5344 }
5345 }
5346
5347 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'static>
5348 where
5349 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5350 ___D: ::fidl_next::Decoder,
5351 ___D: ::fidl_next::fuchsia::HandleDecoder,
5352 {
5353 fn decode(
5354 slot_: ::fidl_next::Slot<'_, Self>,
5355 decoder_: &mut ___D,
5356 _: (),
5357 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5358 ::fidl_next::munge! {
5359 let Self {
5360
5361 mut items,
5362 mut end_id,
5363
5364 } = slot_;
5365 }
5366
5367 let _field = items.as_mut();
5368 ::fidl_next::Constrained::validate(_field, (128, ()))?;
5369 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
5370
5371 let items = unsafe { items.deref_unchecked() };
5372
5373 if items.len() > 128 {
5374 return Err(::fidl_next::DecodeError::VectorTooLong {
5375 size: items.len() as u64,
5376 limit: 128,
5377 });
5378 }
5379
5380 let _field = end_id.as_mut();
5381
5382 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
5383
5384 Ok(())
5385 }
5386 }
5387
5388 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
5389 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
5390 }
5391
5392 impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextResponse<'static> {}
5393
5394 #[derive(Debug)]
5396 #[repr(C)]
5397 pub struct DictionaryOptionalItem<'de> {
5398 pub key: ::fidl_next::WireString<'de>,
5399
5400 pub value: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
5401 }
5402
5403 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
5404 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
5405
5406 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
5407
5408 static_assertions::const_assert_eq!(
5409 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
5410 16
5411 );
5412
5413 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
5414 type Owned<'de> = DictionaryOptionalItem<'de>;
5415
5416 #[inline]
5417 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5418 ::fidl_next::munge! {
5419 let Self {
5420
5421 key,
5422 value,
5423
5424 } = &mut *out_;
5425 }
5426
5427 ::fidl_next::Wire::zero_padding(key);
5428
5429 ::fidl_next::Wire::zero_padding(value);
5430 }
5431 }
5432
5433 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'static>
5434 where
5435 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5436 ___D: ::fidl_next::Decoder,
5437 ___D: ::fidl_next::fuchsia::HandleDecoder,
5438 {
5439 fn decode(
5440 slot_: ::fidl_next::Slot<'_, Self>,
5441 decoder_: &mut ___D,
5442 _: (),
5443 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5444 ::fidl_next::munge! {
5445 let Self {
5446
5447 mut key,
5448 mut value,
5449
5450 } = slot_;
5451 }
5452
5453 let _field = key.as_mut();
5454 ::fidl_next::Constrained::validate(_field, 255)?;
5455 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
5456
5457 let key = unsafe { key.deref_unchecked() };
5458
5459 if key.len() > 255 {
5460 return Err(::fidl_next::DecodeError::VectorTooLong {
5461 size: key.len() as u64,
5462 limit: 255,
5463 });
5464 }
5465
5466 let _field = value.as_mut();
5467
5468 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
5469
5470 Ok(())
5471 }
5472 }
5473
5474 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
5475 type Natural = crate::natural::DictionaryOptionalItem;
5476 }
5477
5478 impl ::fidl_next::Unconstrained for DictionaryOptionalItem<'static> {}
5479
5480 #[derive(Debug)]
5482 #[repr(C)]
5483 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
5484 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryOptionalItem<'de>>,
5485
5486 pub end_id: ::fidl_next::WireU64,
5487 }
5488
5489 static_assertions::const_assert_eq!(
5490 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
5491 24
5492 );
5493 static_assertions::const_assert_eq!(
5494 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
5495 8
5496 );
5497
5498 static_assertions::const_assert_eq!(
5499 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
5500 0
5501 );
5502
5503 static_assertions::const_assert_eq!(
5504 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
5505 16
5506 );
5507
5508 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
5509 type Owned<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
5510
5511 #[inline]
5512 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5513 ::fidl_next::munge! {
5514 let Self {
5515
5516 items,
5517 end_id,
5518
5519 } = &mut *out_;
5520 }
5521
5522 ::fidl_next::Wire::zero_padding(items);
5523
5524 ::fidl_next::Wire::zero_padding(end_id);
5525 }
5526 }
5527
5528 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'static>
5529 where
5530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5531 ___D: ::fidl_next::Decoder,
5532 ___D: ::fidl_next::fuchsia::HandleDecoder,
5533 {
5534 fn decode(
5535 slot_: ::fidl_next::Slot<'_, Self>,
5536 decoder_: &mut ___D,
5537 _: (),
5538 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5539 ::fidl_next::munge! {
5540 let Self {
5541
5542 mut items,
5543 mut end_id,
5544
5545 } = slot_;
5546 }
5547
5548 let _field = items.as_mut();
5549 ::fidl_next::Constrained::validate(_field, (128, ()))?;
5550 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
5551
5552 let items = unsafe { items.deref_unchecked() };
5553
5554 if items.len() > 128 {
5555 return Err(::fidl_next::DecodeError::VectorTooLong {
5556 size: items.len() as u64,
5557 limit: 128,
5558 });
5559 }
5560
5561 let _field = end_id.as_mut();
5562
5563 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
5564
5565 Ok(())
5566 }
5567 }
5568
5569 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
5570 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
5571 }
5572
5573 impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextResponse<'static> {}
5574
5575 #[derive(Debug)]
5577 #[repr(C)]
5578 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
5579 pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
5580 }
5581
5582 static_assertions::const_assert_eq!(
5583 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
5584 16
5585 );
5586 static_assertions::const_assert_eq!(
5587 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
5588 8
5589 );
5590
5591 static_assertions::const_assert_eq!(
5592 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
5593 0
5594 );
5595
5596 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
5597 type Owned<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
5598
5599 #[inline]
5600 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5601 ::fidl_next::munge! {
5602 let Self {
5603
5604 keys,
5605
5606 } = &mut *out_;
5607 }
5608
5609 ::fidl_next::Wire::zero_padding(keys);
5610 }
5611 }
5612
5613 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'static>
5614 where
5615 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5616 ___D: ::fidl_next::Decoder,
5617 ___D: ::fidl_next::fuchsia::HandleDecoder,
5618 {
5619 fn decode(
5620 slot_: ::fidl_next::Slot<'_, Self>,
5621 decoder_: &mut ___D,
5622 _: (),
5623 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5624 ::fidl_next::munge! {
5625 let Self {
5626
5627 mut keys,
5628
5629 } = slot_;
5630 }
5631
5632 let _field = keys.as_mut();
5633 ::fidl_next::Constrained::validate(_field, (128, 255))?;
5634 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
5635
5636 let keys = unsafe { keys.deref_unchecked() };
5637
5638 if keys.len() > 128 {
5639 return Err(::fidl_next::DecodeError::VectorTooLong {
5640 size: keys.len() as u64,
5641 limit: 128,
5642 });
5643 }
5644
5645 Ok(())
5646 }
5647 }
5648
5649 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
5650 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
5651 }
5652
5653 impl ::fidl_next::Unconstrained for DictionaryKeysIteratorGetNextResponse<'static> {}
5654
5655 #[repr(transparent)]
5657 pub struct DictionaryRouterRouteResponse {
5658 pub(crate) raw: ::fidl_next::RawWireUnion,
5659 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5660 }
5661
5662 impl Drop for DictionaryRouterRouteResponse {
5663 fn drop(&mut self) {
5664 match self.raw.ordinal() {
5665 1 => {
5666 let _ =
5667 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
5668 }
5669
5670 2 => {
5671 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5672 }
5673
5674 _ => unsafe { ::core::hint::unreachable_unchecked() },
5675 }
5676 }
5677 }
5678
5679 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
5680 type Owned<'de> = DictionaryRouterRouteResponse;
5681
5682 #[inline]
5683 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5684 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5685 ::fidl_next::RawWireUnion::zero_padding(raw);
5686 }
5687 }
5688
5689 pub mod dictionary_router_route_response {
5690 pub enum Ref<'de> {
5691 Dictionary(&'de crate::wire::DictionaryRef),
5692
5693 Unavailable(&'de crate::wire::Unit),
5694 }
5695 }
5696
5697 impl DictionaryRouterRouteResponse {
5698 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
5699 match self.raw.ordinal() {
5700 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
5701 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
5702 }),
5703
5704 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
5705 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5706 }),
5707
5708 _ => unsafe { ::core::hint::unreachable_unchecked() },
5709 }
5710 }
5711 }
5712
5713 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
5714 where
5715 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5716 ___D: ::fidl_next::fuchsia::HandleDecoder,
5717 {
5718 fn decode(
5719 mut slot: ::fidl_next::Slot<'_, Self>,
5720 decoder: &mut ___D,
5721 _: (),
5722 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5723 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5724 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5725 1 => {
5726 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
5727 raw,
5728 decoder,
5729 (),
5730 )?
5731 }
5732
5733 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5734 raw,
5735 decoder,
5736 (),
5737 )?,
5738
5739 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5740 }
5741
5742 Ok(())
5743 }
5744 }
5745
5746 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
5747 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5748 match self.raw.ordinal() {
5749 1 => unsafe {
5750 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
5751 },
5752 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5753 _ => unsafe { ::core::hint::unreachable_unchecked() },
5754 }
5755 }
5756 }
5757
5758 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
5759 type Natural = crate::natural::DictionaryRouterRouteResponse;
5760 }
5761
5762 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
5763
5764 #[repr(transparent)]
5766 pub struct DirConnectorRouterRouteResponse {
5767 pub(crate) raw: ::fidl_next::RawWireUnion,
5768 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5769 }
5770
5771 impl Drop for DirConnectorRouterRouteResponse {
5772 fn drop(&mut self) {
5773 match self.raw.ordinal() {
5774 1 => {
5775 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
5776 }
5777
5778 2 => {
5779 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5780 }
5781
5782 _ => unsafe { ::core::hint::unreachable_unchecked() },
5783 }
5784 }
5785 }
5786
5787 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
5788 type Owned<'de> = DirConnectorRouterRouteResponse;
5789
5790 #[inline]
5791 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5792 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5793 ::fidl_next::RawWireUnion::zero_padding(raw);
5794 }
5795 }
5796
5797 pub mod dir_connector_router_route_response {
5798 pub enum Ref<'de> {
5799 DirConnector(&'de crate::wire::DirConnector),
5800
5801 Unavailable(&'de crate::wire::Unit),
5802 }
5803 }
5804
5805 impl DirConnectorRouterRouteResponse {
5806 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
5807 match self.raw.ordinal() {
5808 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
5809 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
5810 }),
5811
5812 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
5813 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5814 }),
5815
5816 _ => unsafe { ::core::hint::unreachable_unchecked() },
5817 }
5818 }
5819 }
5820
5821 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
5822 where
5823 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5824 ___D: ::fidl_next::fuchsia::HandleDecoder,
5825 {
5826 fn decode(
5827 mut slot: ::fidl_next::Slot<'_, Self>,
5828 decoder: &mut ___D,
5829 _: (),
5830 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5831 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5832 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5833 1 => {
5834 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
5835 raw,
5836 decoder,
5837 (),
5838 )?
5839 }
5840
5841 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5842 raw,
5843 decoder,
5844 (),
5845 )?,
5846
5847 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5848 }
5849
5850 Ok(())
5851 }
5852 }
5853
5854 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
5855 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5856 match self.raw.ordinal() {
5857 1 => unsafe {
5858 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
5859 },
5860 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5861 _ => unsafe { ::core::hint::unreachable_unchecked() },
5862 }
5863 }
5864 }
5865
5866 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
5867 type Natural = crate::natural::DirConnectorRouterRouteResponse;
5868 }
5869
5870 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
5871
5872 #[repr(transparent)]
5874 pub struct DirEntryRouterRouteResponse {
5875 pub(crate) raw: ::fidl_next::RawWireUnion,
5876 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5877 }
5878
5879 impl Drop for DirEntryRouterRouteResponse {
5880 fn drop(&mut self) {
5881 match self.raw.ordinal() {
5882 1 => {
5883 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
5884 }
5885
5886 2 => {
5887 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5888 }
5889
5890 _ => unsafe { ::core::hint::unreachable_unchecked() },
5891 }
5892 }
5893 }
5894
5895 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
5896 type Owned<'de> = DirEntryRouterRouteResponse;
5897
5898 #[inline]
5899 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5900 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5901 ::fidl_next::RawWireUnion::zero_padding(raw);
5902 }
5903 }
5904
5905 pub mod dir_entry_router_route_response {
5906 pub enum Ref<'de> {
5907 DirEntry(&'de crate::wire::DirEntry),
5908
5909 Unavailable(&'de crate::wire::Unit),
5910 }
5911 }
5912
5913 impl DirEntryRouterRouteResponse {
5914 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
5915 match self.raw.ordinal() {
5916 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
5917 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
5918 }),
5919
5920 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
5921 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5922 }),
5923
5924 _ => unsafe { ::core::hint::unreachable_unchecked() },
5925 }
5926 }
5927 }
5928
5929 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
5930 where
5931 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5932 ___D: ::fidl_next::fuchsia::HandleDecoder,
5933 {
5934 fn decode(
5935 mut slot: ::fidl_next::Slot<'_, Self>,
5936 decoder: &mut ___D,
5937 _: (),
5938 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5939 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5940 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5941 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
5942 raw,
5943 decoder,
5944 (),
5945 )?,
5946
5947 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5948 raw,
5949 decoder,
5950 (),
5951 )?,
5952
5953 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5954 }
5955
5956 Ok(())
5957 }
5958 }
5959
5960 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
5961 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5962 match self.raw.ordinal() {
5963 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
5964 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5965 _ => unsafe { ::core::hint::unreachable_unchecked() },
5966 }
5967 }
5968 }
5969
5970 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
5971 type Natural = crate::natural::DirEntryRouterRouteResponse;
5972 }
5973
5974 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
5975
5976 #[repr(C)]
5978 pub struct DirReceiverReceiveRequest<'de> {
5979 pub(crate) table: ::fidl_next::WireTable<'de>,
5980 }
5981
5982 impl<'de> Drop for DirReceiverReceiveRequest<'de> {
5983 fn drop(&mut self) {
5984 let _ = self.table.get(1).map(|envelope| unsafe {
5985 envelope.read_unchecked::<::fidl_next::fuchsia::WireChannel>()
5986 });
5987
5988 let _ = self.table.get(2).map(|envelope| unsafe {
5989 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
5990 });
5991
5992 let _ = self.table.get(3).map(|envelope| unsafe {
5993 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
5994 });
5995 }
5996 }
5997
5998 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest<'static> {
5999 type Owned<'de> = DirReceiverReceiveRequest<'de>;
6000
6001 #[inline]
6002 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6003 ::fidl_next::munge!(let Self { table } = out);
6004 ::fidl_next::WireTable::zero_padding(table);
6005 }
6006 }
6007
6008 unsafe impl<___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest<'static>
6009 where
6010 ___D: ::fidl_next::Decoder + ?Sized,
6011 ___D: ::fidl_next::fuchsia::HandleDecoder,
6012 {
6013 fn decode(
6014 slot: ::fidl_next::Slot<'_, Self>,
6015 decoder: &mut ___D,
6016 _: (),
6017 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6018 ::fidl_next::munge!(let Self { table } = slot);
6019
6020 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
6021 match ordinal {
6022 0 => unsafe { ::core::hint::unreachable_unchecked() },
6023
6024 1 => {
6025 ::fidl_next::WireEnvelope::decode_as::<
6026 ___D,
6027 ::fidl_next::fuchsia::WireChannel,
6028 >(slot.as_mut(), decoder, ())?;
6029
6030 Ok(())
6031 }
6032
6033 2 => {
6034 ::fidl_next::WireEnvelope::decode_as::<
6035 ___D,
6036 ::fidl_next_fuchsia_io::wire::Flags,
6037 >(slot.as_mut(), decoder, ())?;
6038
6039 Ok(())
6040 }
6041
6042 3 => {
6043 ::fidl_next::WireEnvelope::decode_as::<
6044 ___D,
6045 ::fidl_next::WireString<'static>,
6046 >(slot.as_mut(), decoder, 4095)?;
6047
6048 let value = unsafe {
6049 slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
6050 };
6051
6052 if value.len() > 4095 {
6053 return Err(::fidl_next::DecodeError::VectorTooLong {
6054 size: value.len() as u64,
6055 limit: 4095,
6056 });
6057 }
6058
6059 Ok(())
6060 }
6061
6062 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
6063 }
6064 })
6065 }
6066 }
6067
6068 impl<'de> DirReceiverReceiveRequest<'de> {
6069 pub fn channel(&self) -> ::core::option::Option<&::fidl_next::fuchsia::WireChannel> {
6070 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
6071 }
6072
6073 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
6074 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
6075 }
6076
6077 pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
6078 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
6079 }
6080 }
6081
6082 impl<'de> ::core::fmt::Debug for DirReceiverReceiveRequest<'de> {
6083 fn fmt(
6084 &self,
6085 f: &mut ::core::fmt::Formatter<'_>,
6086 ) -> ::core::result::Result<(), ::core::fmt::Error> {
6087 f.debug_struct("DirReceiverReceiveRequest")
6088 .field("channel", &self.channel())
6089 .field("flags", &self.flags())
6090 .field("subdir", &self.subdir())
6091 .finish()
6092 }
6093 }
6094
6095 impl<'de> ::fidl_next::IntoNatural for DirReceiverReceiveRequest<'de> {
6096 type Natural = crate::natural::DirReceiverReceiveRequest;
6097 }
6098
6099 impl ::fidl_next::Unconstrained for DirReceiverReceiveRequest<'_> {}
6100
6101 #[repr(transparent)]
6103 pub struct DirectoryRouterRouteResponse {
6104 pub(crate) raw: ::fidl_next::RawWireUnion,
6105 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6106 }
6107
6108 impl Drop for DirectoryRouterRouteResponse {
6109 fn drop(&mut self) {
6110 match self.raw.ordinal() {
6111 1 => {
6112 let _ = unsafe {
6113 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
6114 ::fidl_next_fuchsia_io::Directory,
6115 ::fidl_next::fuchsia::WireChannel,
6116 >>()
6117 };
6118 }
6119
6120 2 => {
6121 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6122 }
6123
6124 _ => unsafe { ::core::hint::unreachable_unchecked() },
6125 }
6126 }
6127 }
6128
6129 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
6130 type Owned<'de> = DirectoryRouterRouteResponse;
6131
6132 #[inline]
6133 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6134 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6135 ::fidl_next::RawWireUnion::zero_padding(raw);
6136 }
6137 }
6138
6139 pub mod directory_router_route_response {
6140 pub enum Ref<'de> {
6141 Directory(
6142 &'de ::fidl_next::ClientEnd<
6143 ::fidl_next_fuchsia_io::Directory,
6144 ::fidl_next::fuchsia::WireChannel,
6145 >,
6146 ),
6147
6148 Unavailable(&'de crate::wire::Unit),
6149 }
6150 }
6151
6152 impl DirectoryRouterRouteResponse {
6153 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
6154 match self.raw.ordinal() {
6155 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
6156 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
6157 ::fidl_next_fuchsia_io::Directory,
6158 ::fidl_next::fuchsia::WireChannel,
6159 >>()
6160 }),
6161
6162 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
6163 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6164 }),
6165
6166 _ => unsafe { ::core::hint::unreachable_unchecked() },
6167 }
6168 }
6169 }
6170
6171 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
6172 where
6173 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6174 ___D: ::fidl_next::fuchsia::HandleDecoder,
6175 {
6176 fn decode(
6177 mut slot: ::fidl_next::Slot<'_, Self>,
6178 decoder: &mut ___D,
6179 _: (),
6180 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6181 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6182 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6183 1 => ::fidl_next::RawWireUnion::decode_as_static::<
6184 ___D,
6185 ::fidl_next::ClientEnd<
6186 ::fidl_next_fuchsia_io::Directory,
6187 ::fidl_next::fuchsia::WireChannel,
6188 >,
6189 >(raw, decoder, ())?,
6190
6191 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6192 raw,
6193 decoder,
6194 (),
6195 )?,
6196
6197 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6198 }
6199
6200 Ok(())
6201 }
6202 }
6203
6204 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
6205 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6206 match self.raw.ordinal() {
6207 1 => unsafe {
6208 self.raw
6209 .get()
6210 .deref_unchecked::<::fidl_next::ClientEnd<
6211 ::fidl_next_fuchsia_io::Directory,
6212 ::fidl_next::fuchsia::WireChannel,
6213 >>()
6214 .fmt(f)
6215 },
6216 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6217 _ => unsafe { ::core::hint::unreachable_unchecked() },
6218 }
6219 }
6220 }
6221
6222 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
6223 type Natural = crate::natural::DirectoryRouterRouteResponse;
6224 }
6225
6226 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
6227
6228 #[derive(Debug)]
6230 #[repr(C)]
6231 pub struct ProtocolPayload {
6232 pub channel: ::fidl_next::fuchsia::WireChannel,
6233 }
6234
6235 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
6236 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
6237
6238 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
6239
6240 unsafe impl ::fidl_next::Wire for ProtocolPayload {
6241 type Owned<'de> = ProtocolPayload;
6242
6243 #[inline]
6244 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6245 ::fidl_next::munge! {
6246 let Self {
6247
6248 channel,
6249
6250 } = &mut *out_;
6251 }
6252
6253 ::fidl_next::Wire::zero_padding(channel);
6254 }
6255 }
6256
6257 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
6258 where
6259 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6260 ___D: ::fidl_next::fuchsia::HandleDecoder,
6261 {
6262 fn decode(
6263 slot_: ::fidl_next::Slot<'_, Self>,
6264 decoder_: &mut ___D,
6265 _: (),
6266 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6267 ::fidl_next::munge! {
6268 let Self {
6269
6270 mut channel,
6271
6272 } = slot_;
6273 }
6274
6275 let _field = channel.as_mut();
6276
6277 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
6278
6279 Ok(())
6280 }
6281 }
6282
6283 impl ::fidl_next::IntoNatural for ProtocolPayload {
6284 type Natural = crate::natural::ProtocolPayload;
6285 }
6286
6287 impl ::fidl_next::Unconstrained for ProtocolPayload {}
6288}
6289
6290pub mod wire_optional {
6291
6292 pub use fidl_next_common_fuchsia_component_sandbox::wire_optional::*;
6293
6294 #[repr(transparent)]
6295 pub struct Capability<'de> {
6296 pub(crate) raw: ::fidl_next::RawWireUnion,
6297 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6298 }
6299
6300 unsafe impl ::fidl_next::Wire for Capability<'static> {
6301 type Owned<'de> = Capability<'de>;
6302
6303 #[inline]
6304 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6305 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6306 ::fidl_next::RawWireUnion::zero_padding(raw);
6307 }
6308 }
6309
6310 impl<'de> Capability<'de> {
6311 pub fn is_some(&self) -> bool {
6312 self.raw.is_some()
6313 }
6314
6315 pub fn is_none(&self) -> bool {
6316 self.raw.is_none()
6317 }
6318
6319 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
6320 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6321 }
6322
6323 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
6324 if self.is_some() {
6325 Some(crate::wire::Capability {
6326 raw: self.raw,
6327 _phantom: ::core::marker::PhantomData,
6328 })
6329 } else {
6330 None
6331 }
6332 }
6333 }
6334
6335 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
6336 where
6337 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6338 ___D: ::fidl_next::Decoder,
6339 ___D: ::fidl_next::fuchsia::HandleDecoder,
6340 {
6341 fn decode(
6342 mut slot: ::fidl_next::Slot<'_, Self>,
6343 decoder: &mut ___D,
6344 _: (),
6345 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6346 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6347 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6348 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
6349 raw,
6350 decoder,
6351 (),
6352 )?,
6353
6354 2 => ::fidl_next::RawWireUnion::decode_as::<
6355 ___D,
6356 ::fidl_next::fuchsia::WireNullableHandle,
6357 >(raw, decoder, ())?,
6358
6359 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
6360 raw,
6361 decoder,
6362 (),
6363 )?,
6364
6365 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
6366 raw,
6367 decoder,
6368 (),
6369 )?,
6370
6371 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
6372 raw,
6373 decoder,
6374 (),
6375 )?,
6376
6377 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
6378 raw,
6379 decoder,
6380 (),
6381 )?,
6382
6383 7 => ::fidl_next::RawWireUnion::decode_as::<
6384 ___D,
6385 ::fidl_next::ClientEnd<
6386 ::fidl_next_fuchsia_io::Directory,
6387 ::fidl_next::fuchsia::WireChannel,
6388 >,
6389 >(raw, decoder, ())?,
6390
6391 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
6392 raw,
6393 decoder,
6394 (),
6395 )?,
6396
6397 9 => ::fidl_next::RawWireUnion::decode_as::<
6398 ___D,
6399 ::fidl_next::ClientEnd<
6400 crate::ConnectorRouter,
6401 ::fidl_next::fuchsia::WireChannel,
6402 >,
6403 >(raw, decoder, ())?,
6404
6405 10 => ::fidl_next::RawWireUnion::decode_as::<
6406 ___D,
6407 ::fidl_next::ClientEnd<
6408 crate::DictionaryRouter,
6409 ::fidl_next::fuchsia::WireChannel,
6410 >,
6411 >(raw, decoder, ())?,
6412
6413 11 => ::fidl_next::RawWireUnion::decode_as::<
6414 ___D,
6415 ::fidl_next::ClientEnd<
6416 crate::DirEntryRouter,
6417 ::fidl_next::fuchsia::WireChannel,
6418 >,
6419 >(raw, decoder, ())?,
6420
6421 12 => ::fidl_next::RawWireUnion::decode_as::<
6422 ___D,
6423 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
6424 >(raw, decoder, ())?,
6425
6426 13 => ::fidl_next::RawWireUnion::decode_as::<
6427 ___D,
6428 ::fidl_next::ClientEnd<
6429 crate::DirConnectorRouter,
6430 ::fidl_next::fuchsia::WireChannel,
6431 >,
6432 >(raw, decoder, ())?,
6433
6434 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6435 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
6436 }
6437
6438 Ok(())
6439 }
6440 }
6441
6442 impl<'de> ::core::fmt::Debug for Capability<'de> {
6443 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6444 self.as_ref().fmt(f)
6445 }
6446 }
6447
6448 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
6449 type Natural = ::core::option::Option<crate::natural::Capability>;
6450 }
6451
6452 impl ::fidl_next::Unconstrained for Capability<'static> {}
6453
6454 #[repr(transparent)]
6455 pub struct ConnectorRouterRouteResponse {
6456 pub(crate) raw: ::fidl_next::RawWireUnion,
6457 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6458 }
6459
6460 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
6461 type Owned<'de> = ConnectorRouterRouteResponse;
6462
6463 #[inline]
6464 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6465 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6466 ::fidl_next::RawWireUnion::zero_padding(raw);
6467 }
6468 }
6469
6470 impl ConnectorRouterRouteResponse {
6471 pub fn is_some(&self) -> bool {
6472 self.raw.is_some()
6473 }
6474
6475 pub fn is_none(&self) -> bool {
6476 self.raw.is_none()
6477 }
6478
6479 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
6480 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6481 }
6482
6483 pub fn into_option(
6484 self,
6485 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
6486 if self.is_some() {
6487 Some(crate::wire::ConnectorRouterRouteResponse {
6488 raw: self.raw,
6489 _phantom: ::core::marker::PhantomData,
6490 })
6491 } else {
6492 None
6493 }
6494 }
6495 }
6496
6497 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
6498 where
6499 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6500 ___D: ::fidl_next::fuchsia::HandleDecoder,
6501 {
6502 fn decode(
6503 mut slot: ::fidl_next::Slot<'_, Self>,
6504 decoder: &mut ___D,
6505 _: (),
6506 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6507 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6508 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6509 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
6510 raw,
6511 decoder,
6512 (),
6513 )?,
6514
6515 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6516 raw,
6517 decoder,
6518 (),
6519 )?,
6520
6521 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6522 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6523 }
6524
6525 Ok(())
6526 }
6527 }
6528
6529 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
6530 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6531 self.as_ref().fmt(f)
6532 }
6533 }
6534
6535 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
6536 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
6537 }
6538
6539 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
6540
6541 #[repr(transparent)]
6542 pub struct DataRouterRouteResponse<'de> {
6543 pub(crate) raw: ::fidl_next::RawWireUnion,
6544 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6545 }
6546
6547 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
6548 type Owned<'de> = DataRouterRouteResponse<'de>;
6549
6550 #[inline]
6551 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6552 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6553 ::fidl_next::RawWireUnion::zero_padding(raw);
6554 }
6555 }
6556
6557 impl<'de> DataRouterRouteResponse<'de> {
6558 pub fn is_some(&self) -> bool {
6559 self.raw.is_some()
6560 }
6561
6562 pub fn is_none(&self) -> bool {
6563 self.raw.is_none()
6564 }
6565
6566 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
6567 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6568 }
6569
6570 pub fn into_option(
6571 self,
6572 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
6573 if self.is_some() {
6574 Some(crate::wire::DataRouterRouteResponse {
6575 raw: self.raw,
6576 _phantom: ::core::marker::PhantomData,
6577 })
6578 } else {
6579 None
6580 }
6581 }
6582 }
6583
6584 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
6585 where
6586 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6587 ___D: ::fidl_next::Decoder,
6588 ___D: ::fidl_next::fuchsia::HandleDecoder,
6589 {
6590 fn decode(
6591 mut slot: ::fidl_next::Slot<'_, Self>,
6592 decoder: &mut ___D,
6593 _: (),
6594 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6595 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6596 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6597 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
6598 raw,
6599 decoder,
6600 (),
6601 )?,
6602
6603 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
6604 raw,
6605 decoder,
6606 (),
6607 )?,
6608
6609 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6610 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
6611 }
6612
6613 Ok(())
6614 }
6615 }
6616
6617 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
6618 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6619 self.as_ref().fmt(f)
6620 }
6621 }
6622
6623 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
6624 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
6625 }
6626
6627 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
6628
6629 #[repr(transparent)]
6630 pub struct DictionaryRouterRouteResponse {
6631 pub(crate) raw: ::fidl_next::RawWireUnion,
6632 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6633 }
6634
6635 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
6636 type Owned<'de> = DictionaryRouterRouteResponse;
6637
6638 #[inline]
6639 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6640 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6641 ::fidl_next::RawWireUnion::zero_padding(raw);
6642 }
6643 }
6644
6645 impl DictionaryRouterRouteResponse {
6646 pub fn is_some(&self) -> bool {
6647 self.raw.is_some()
6648 }
6649
6650 pub fn is_none(&self) -> bool {
6651 self.raw.is_none()
6652 }
6653
6654 pub fn as_ref(
6655 &self,
6656 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
6657 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6658 }
6659
6660 pub fn into_option(
6661 self,
6662 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
6663 if self.is_some() {
6664 Some(crate::wire::DictionaryRouterRouteResponse {
6665 raw: self.raw,
6666 _phantom: ::core::marker::PhantomData,
6667 })
6668 } else {
6669 None
6670 }
6671 }
6672 }
6673
6674 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
6675 where
6676 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6677 ___D: ::fidl_next::fuchsia::HandleDecoder,
6678 {
6679 fn decode(
6680 mut slot: ::fidl_next::Slot<'_, Self>,
6681 decoder: &mut ___D,
6682 _: (),
6683 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6684 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6685 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6686 1 => {
6687 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
6688 raw,
6689 decoder,
6690 (),
6691 )?
6692 }
6693
6694 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6695 raw,
6696 decoder,
6697 (),
6698 )?,
6699
6700 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6701 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6702 }
6703
6704 Ok(())
6705 }
6706 }
6707
6708 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
6709 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6710 self.as_ref().fmt(f)
6711 }
6712 }
6713
6714 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
6715 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
6716 }
6717
6718 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
6719
6720 #[repr(transparent)]
6721 pub struct DirConnectorRouterRouteResponse {
6722 pub(crate) raw: ::fidl_next::RawWireUnion,
6723 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6724 }
6725
6726 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
6727 type Owned<'de> = DirConnectorRouterRouteResponse;
6728
6729 #[inline]
6730 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6731 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6732 ::fidl_next::RawWireUnion::zero_padding(raw);
6733 }
6734 }
6735
6736 impl DirConnectorRouterRouteResponse {
6737 pub fn is_some(&self) -> bool {
6738 self.raw.is_some()
6739 }
6740
6741 pub fn is_none(&self) -> bool {
6742 self.raw.is_none()
6743 }
6744
6745 pub fn as_ref(
6746 &self,
6747 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
6748 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6749 }
6750
6751 pub fn into_option(
6752 self,
6753 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
6754 if self.is_some() {
6755 Some(crate::wire::DirConnectorRouterRouteResponse {
6756 raw: self.raw,
6757 _phantom: ::core::marker::PhantomData,
6758 })
6759 } else {
6760 None
6761 }
6762 }
6763 }
6764
6765 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
6766 where
6767 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6768 ___D: ::fidl_next::fuchsia::HandleDecoder,
6769 {
6770 fn decode(
6771 mut slot: ::fidl_next::Slot<'_, Self>,
6772 decoder: &mut ___D,
6773 _: (),
6774 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6775 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6776 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6777 1 => {
6778 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
6779 raw,
6780 decoder,
6781 (),
6782 )?
6783 }
6784
6785 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6786 raw,
6787 decoder,
6788 (),
6789 )?,
6790
6791 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6792 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6793 }
6794
6795 Ok(())
6796 }
6797 }
6798
6799 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
6800 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6801 self.as_ref().fmt(f)
6802 }
6803 }
6804
6805 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
6806 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
6807 }
6808
6809 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
6810
6811 #[repr(transparent)]
6812 pub struct DirEntryRouterRouteResponse {
6813 pub(crate) raw: ::fidl_next::RawWireUnion,
6814 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6815 }
6816
6817 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
6818 type Owned<'de> = DirEntryRouterRouteResponse;
6819
6820 #[inline]
6821 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6822 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6823 ::fidl_next::RawWireUnion::zero_padding(raw);
6824 }
6825 }
6826
6827 impl DirEntryRouterRouteResponse {
6828 pub fn is_some(&self) -> bool {
6829 self.raw.is_some()
6830 }
6831
6832 pub fn is_none(&self) -> bool {
6833 self.raw.is_none()
6834 }
6835
6836 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
6837 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6838 }
6839
6840 pub fn into_option(
6841 self,
6842 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
6843 if self.is_some() {
6844 Some(crate::wire::DirEntryRouterRouteResponse {
6845 raw: self.raw,
6846 _phantom: ::core::marker::PhantomData,
6847 })
6848 } else {
6849 None
6850 }
6851 }
6852 }
6853
6854 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
6855 where
6856 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6857 ___D: ::fidl_next::fuchsia::HandleDecoder,
6858 {
6859 fn decode(
6860 mut slot: ::fidl_next::Slot<'_, Self>,
6861 decoder: &mut ___D,
6862 _: (),
6863 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6864 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6865 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6866 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
6867 raw,
6868 decoder,
6869 (),
6870 )?,
6871
6872 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6873 raw,
6874 decoder,
6875 (),
6876 )?,
6877
6878 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6879 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6880 }
6881
6882 Ok(())
6883 }
6884 }
6885
6886 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
6887 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6888 self.as_ref().fmt(f)
6889 }
6890 }
6891
6892 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
6893 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
6894 }
6895
6896 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
6897
6898 #[repr(transparent)]
6899 pub struct DirectoryRouterRouteResponse {
6900 pub(crate) raw: ::fidl_next::RawWireUnion,
6901 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6902 }
6903
6904 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
6905 type Owned<'de> = DirectoryRouterRouteResponse;
6906
6907 #[inline]
6908 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6909 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6910 ::fidl_next::RawWireUnion::zero_padding(raw);
6911 }
6912 }
6913
6914 impl DirectoryRouterRouteResponse {
6915 pub fn is_some(&self) -> bool {
6916 self.raw.is_some()
6917 }
6918
6919 pub fn is_none(&self) -> bool {
6920 self.raw.is_none()
6921 }
6922
6923 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
6924 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6925 }
6926
6927 pub fn into_option(
6928 self,
6929 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
6930 if self.is_some() {
6931 Some(crate::wire::DirectoryRouterRouteResponse {
6932 raw: self.raw,
6933 _phantom: ::core::marker::PhantomData,
6934 })
6935 } else {
6936 None
6937 }
6938 }
6939 }
6940
6941 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
6942 where
6943 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6944 ___D: ::fidl_next::fuchsia::HandleDecoder,
6945 {
6946 fn decode(
6947 mut slot: ::fidl_next::Slot<'_, Self>,
6948 decoder: &mut ___D,
6949 _: (),
6950 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6951 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6952 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6953 1 => ::fidl_next::RawWireUnion::decode_as_static::<
6954 ___D,
6955 ::fidl_next::ClientEnd<
6956 ::fidl_next_fuchsia_io::Directory,
6957 ::fidl_next::fuchsia::WireChannel,
6958 >,
6959 >(raw, decoder, ())?,
6960
6961 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6962 raw,
6963 decoder,
6964 (),
6965 )?,
6966
6967 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
6968 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
6969 }
6970
6971 Ok(())
6972 }
6973 }
6974
6975 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
6976 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6977 self.as_ref().fmt(f)
6978 }
6979 }
6980
6981 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
6982 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
6983 }
6984
6985 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
6986}
6987
6988pub mod generic {
6989
6990 pub use fidl_next_common_fuchsia_component_sandbox::generic::*;
6991
6992 pub struct DictionaryRef<T0> {
6993 pub token: T0,
6994 }
6995
6996 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef<T0>
6997 where
6998 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6999 ___E: ::fidl_next::fuchsia::HandleEncoder,
7000 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7001 {
7002 #[inline]
7003 fn encode(
7004 self,
7005 encoder_: &mut ___E,
7006 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
7007 _: (),
7008 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7009 ::fidl_next::munge! {
7010 let crate::wire::DictionaryRef {
7011
7012 token,
7013
7014 } = out_;
7015 }
7016
7017 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7018
7019 Ok(())
7020 }
7021 }
7022
7023 pub struct Connector<T0> {
7024 pub token: T0,
7025 }
7026
7027 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector<T0>
7028 where
7029 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7030 ___E: ::fidl_next::fuchsia::HandleEncoder,
7031 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7032 {
7033 #[inline]
7034 fn encode(
7035 self,
7036 encoder_: &mut ___E,
7037 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
7038 _: (),
7039 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7040 ::fidl_next::munge! {
7041 let crate::wire::Connector {
7042
7043 token,
7044
7045 } = out_;
7046 }
7047
7048 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7049
7050 Ok(())
7051 }
7052 }
7053
7054 pub struct DirConnector<T0> {
7055 pub token: T0,
7056 }
7057
7058 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector<T0>
7059 where
7060 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7061 ___E: ::fidl_next::fuchsia::HandleEncoder,
7062 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7063 {
7064 #[inline]
7065 fn encode(
7066 self,
7067 encoder_: &mut ___E,
7068 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
7069 _: (),
7070 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7071 ::fidl_next::munge! {
7072 let crate::wire::DirConnector {
7073
7074 token,
7075
7076 } = out_;
7077 }
7078
7079 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7080
7081 Ok(())
7082 }
7083 }
7084
7085 pub struct DirEntry<T0> {
7086 pub token: T0,
7087 }
7088
7089 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry<T0>
7090 where
7091 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7092 ___E: ::fidl_next::fuchsia::HandleEncoder,
7093 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7094 {
7095 #[inline]
7096 fn encode(
7097 self,
7098 encoder_: &mut ___E,
7099 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
7100 _: (),
7101 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7102 ::fidl_next::munge! {
7103 let crate::wire::DirEntry {
7104
7105 token,
7106
7107 } = out_;
7108 }
7109
7110 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7111
7112 Ok(())
7113 }
7114 }
7115
7116 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
7117 pub id: T0,
7118
7119 pub receiver: T1,
7120 }
7121
7122 unsafe impl<___E, T0, T1>
7123 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
7124 for CapabilityStoreConnectorCreateRequest<T0, T1>
7125 where
7126 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7127 ___E: ::fidl_next::fuchsia::HandleEncoder,
7128 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7129 T1: ::fidl_next::Encode<
7130 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
7131 ___E,
7132 >,
7133 {
7134 #[inline]
7135 fn encode(
7136 self,
7137 encoder_: &mut ___E,
7138 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
7139 _: (),
7140 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7141 ::fidl_next::munge! {
7142 let crate::wire::CapabilityStoreConnectorCreateRequest {
7143
7144 id,
7145 receiver,
7146
7147 } = out_;
7148 }
7149
7150 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7151
7152 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
7153
7154 Ok(())
7155 }
7156 }
7157
7158 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
7159 pub id: T0,
7160
7161 pub server_end: T1,
7162 }
7163
7164 unsafe impl<___E, T0, T1>
7165 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
7166 for CapabilityStoreConnectorOpenRequest<T0, T1>
7167 where
7168 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7169 ___E: ::fidl_next::fuchsia::HandleEncoder,
7170 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7171 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7172 {
7173 #[inline]
7174 fn encode(
7175 self,
7176 encoder_: &mut ___E,
7177 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
7178 _: (),
7179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7180 ::fidl_next::munge! {
7181 let crate::wire::CapabilityStoreConnectorOpenRequest {
7182
7183 id,
7184 server_end,
7185
7186 } = out_;
7187 }
7188
7189 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7190
7191 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7192
7193 Ok(())
7194 }
7195 }
7196
7197 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
7198 pub id: T0,
7199
7200 pub receiver: T1,
7201 }
7202
7203 unsafe impl<___E, T0, T1>
7204 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
7205 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
7206 where
7207 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7208 ___E: ::fidl_next::fuchsia::HandleEncoder,
7209 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7210 T1: ::fidl_next::Encode<
7211 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
7212 ___E,
7213 >,
7214 {
7215 #[inline]
7216 fn encode(
7217 self,
7218 encoder_: &mut ___E,
7219 out_: &mut ::core::mem::MaybeUninit<
7220 crate::wire::CapabilityStoreDirConnectorCreateRequest,
7221 >,
7222 _: (),
7223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7224 ::fidl_next::munge! {
7225 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
7226
7227 id,
7228 receiver,
7229
7230 } = out_;
7231 }
7232
7233 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7234
7235 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
7236
7237 Ok(())
7238 }
7239 }
7240
7241 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
7242 pub id: T0,
7243
7244 pub client_end: T1,
7245 }
7246
7247 unsafe impl<___E, T0, T1>
7248 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
7249 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
7250 where
7251 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7252 ___E: ::fidl_next::fuchsia::HandleEncoder,
7253 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7254 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7255 {
7256 #[inline]
7257 fn encode(
7258 self,
7259 encoder_: &mut ___E,
7260 out_: &mut ::core::mem::MaybeUninit<
7261 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
7262 >,
7263 _: (),
7264 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7265 ::fidl_next::munge! {
7266 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
7267
7268 id,
7269 client_end,
7270
7271 } = out_;
7272 }
7273
7274 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7275
7276 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
7277
7278 Ok(())
7279 }
7280 }
7281
7282 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
7283 pub id: T0,
7284
7285 pub server_end: T1,
7286 }
7287
7288 unsafe impl<___E, T0, T1>
7289 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
7290 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
7291 where
7292 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7293 ___E: ::fidl_next::fuchsia::HandleEncoder,
7294 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7295 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7296 {
7297 #[inline]
7298 fn encode(
7299 self,
7300 encoder_: &mut ___E,
7301 out_: &mut ::core::mem::MaybeUninit<
7302 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
7303 >,
7304 _: (),
7305 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7306 ::fidl_next::munge! {
7307 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
7308
7309 id,
7310 server_end,
7311
7312 } = out_;
7313 }
7314
7315 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7316
7317 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7318
7319 Ok(())
7320 }
7321 }
7322
7323 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
7324 pub id: T0,
7325
7326 pub iterator: T1,
7327 }
7328
7329 unsafe impl<___E, T0, T1>
7330 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
7331 for CapabilityStoreDictionaryKeysRequest<T0, T1>
7332 where
7333 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7334 ___E: ::fidl_next::fuchsia::HandleEncoder,
7335 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7336 T1: ::fidl_next::Encode<
7337 ::fidl_next::ServerEnd<
7338 crate::DictionaryKeysIterator,
7339 ::fidl_next::fuchsia::WireChannel,
7340 >,
7341 ___E,
7342 >,
7343 {
7344 #[inline]
7345 fn encode(
7346 self,
7347 encoder_: &mut ___E,
7348 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
7349 _: (),
7350 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7351 ::fidl_next::munge! {
7352 let crate::wire::CapabilityStoreDictionaryKeysRequest {
7353
7354 id,
7355 iterator,
7356
7357 } = out_;
7358 }
7359
7360 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7361
7362 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7363
7364 Ok(())
7365 }
7366 }
7367
7368 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
7369 pub id: T0,
7370
7371 pub iterator: T1,
7372 }
7373
7374 unsafe impl<___E, T0, T1>
7375 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
7376 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
7377 where
7378 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7379 ___E: ::fidl_next::fuchsia::HandleEncoder,
7380 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7381 T1: ::fidl_next::Encode<
7382 ::fidl_next::ServerEnd<
7383 crate::DictionaryEnumerateIterator,
7384 ::fidl_next::fuchsia::WireChannel,
7385 >,
7386 ___E,
7387 >,
7388 {
7389 #[inline]
7390 fn encode(
7391 self,
7392 encoder_: &mut ___E,
7393 out_: &mut ::core::mem::MaybeUninit<
7394 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
7395 >,
7396 _: (),
7397 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7398 ::fidl_next::munge! {
7399 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
7400
7401 id,
7402 iterator,
7403
7404 } = out_;
7405 }
7406
7407 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7408
7409 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7410
7411 Ok(())
7412 }
7413 }
7414
7415 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
7416 pub id: T0,
7417
7418 pub iterator: T1,
7419 }
7420
7421 unsafe impl<___E, T0, T1>
7422 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
7423 for CapabilityStoreDictionaryDrainRequest<T0, T1>
7424 where
7425 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7426 ___E: ::fidl_next::fuchsia::HandleEncoder,
7427 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7428 T1: ::fidl_next::Encode<
7429 ::fidl_next::ServerEnd<
7430 crate::DictionaryDrainIterator,
7431 ::fidl_next::fuchsia::WireOptionalChannel,
7432 >,
7433 ___E,
7434 >,
7435 {
7436 #[inline]
7437 fn encode(
7438 self,
7439 encoder_: &mut ___E,
7440 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
7441 _: (),
7442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7443 ::fidl_next::munge! {
7444 let crate::wire::CapabilityStoreDictionaryDrainRequest {
7445
7446 id,
7447 iterator,
7448
7449 } = out_;
7450 }
7451
7452 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7453
7454 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7455
7456 Ok(())
7457 }
7458 }
7459
7460 pub struct CapabilityStoreExportResponse<T0> {
7461 pub capability: T0,
7462 }
7463
7464 unsafe impl<___E, T0>
7465 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
7466 for CapabilityStoreExportResponse<T0>
7467 where
7468 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7469 ___E: ::fidl_next::Encoder,
7470 ___E: ::fidl_next::fuchsia::HandleEncoder,
7471 T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
7472 {
7473 #[inline]
7474 fn encode(
7475 self,
7476 encoder_: &mut ___E,
7477 out_: &mut ::core::mem::MaybeUninit<
7478 crate::wire::CapabilityStoreExportResponse<'static>,
7479 >,
7480 _: (),
7481 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7482 ::fidl_next::munge! {
7483 let crate::wire::CapabilityStoreExportResponse {
7484
7485 capability,
7486
7487 } = out_;
7488 }
7489
7490 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7491
7492 Ok(())
7493 }
7494 }
7495
7496 pub struct CapabilityStoreImportRequest<T0, T1> {
7497 pub id: T0,
7498
7499 pub capability: T1,
7500 }
7501
7502 unsafe impl<___E, T0, T1>
7503 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
7504 for CapabilityStoreImportRequest<T0, T1>
7505 where
7506 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7507 ___E: ::fidl_next::Encoder,
7508 ___E: ::fidl_next::fuchsia::HandleEncoder,
7509 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7510 T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
7511 {
7512 #[inline]
7513 fn encode(
7514 self,
7515 encoder_: &mut ___E,
7516 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
7517 _: (),
7518 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7519 ::fidl_next::munge! {
7520 let crate::wire::CapabilityStoreImportRequest {
7521
7522 id,
7523 capability,
7524
7525 } = out_;
7526 }
7527
7528 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7529
7530 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7531
7532 Ok(())
7533 }
7534 }
7535
7536 pub struct InstanceToken<T0> {
7537 pub token: T0,
7538 }
7539
7540 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken<T0>
7541 where
7542 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7543 ___E: ::fidl_next::fuchsia::HandleEncoder,
7544 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7545 {
7546 #[inline]
7547 fn encode(
7548 self,
7549 encoder_: &mut ___E,
7550 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
7551 _: (),
7552 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7553 ::fidl_next::munge! {
7554 let crate::wire::InstanceToken {
7555
7556 token,
7557
7558 } = out_;
7559 }
7560
7561 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7562
7563 Ok(())
7564 }
7565 }
7566
7567 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
7568 pub items: T0,
7569
7570 pub end_id: T1,
7571 }
7572
7573 unsafe impl<___E, T0, T1>
7574 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
7575 for DictionaryDrainIteratorGetNextResponse<T0, T1>
7576 where
7577 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7578 ___E: ::fidl_next::Encoder,
7579 ___E: ::fidl_next::fuchsia::HandleEncoder,
7580 T0: ::fidl_next::Encode<
7581 ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
7582 ___E,
7583 >,
7584 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7585 {
7586 #[inline]
7587 fn encode(
7588 self,
7589 encoder_: &mut ___E,
7590 out_: &mut ::core::mem::MaybeUninit<
7591 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
7592 >,
7593 _: (),
7594 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7595 ::fidl_next::munge! {
7596 let crate::wire::DictionaryDrainIteratorGetNextResponse {
7597
7598 items,
7599 end_id,
7600
7601 } = out_;
7602 }
7603
7604 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
7605
7606 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
7607
7608 Ok(())
7609 }
7610 }
7611
7612 pub struct DictionaryOptionalItem<T0, T1> {
7613 pub key: T0,
7614
7615 pub value: T1,
7616 }
7617
7618 unsafe impl<___E, T0, T1>
7619 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
7620 for DictionaryOptionalItem<T0, T1>
7621 where
7622 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7623 ___E: ::fidl_next::Encoder,
7624 ___E: ::fidl_next::fuchsia::HandleEncoder,
7625 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
7626 T1: ::fidl_next::Encode<
7627 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
7628 ___E,
7629 >,
7630 {
7631 #[inline]
7632 fn encode(
7633 self,
7634 encoder_: &mut ___E,
7635 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
7636 _: (),
7637 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7638 ::fidl_next::munge! {
7639 let crate::wire::DictionaryOptionalItem {
7640
7641 key,
7642 value,
7643
7644 } = out_;
7645 }
7646
7647 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
7648
7649 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
7650
7651 Ok(())
7652 }
7653 }
7654
7655 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
7656 pub items: T0,
7657
7658 pub end_id: T1,
7659 }
7660
7661 unsafe impl<___E, T0, T1>
7662 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
7663 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
7664 where
7665 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7666 ___E: ::fidl_next::Encoder,
7667 ___E: ::fidl_next::fuchsia::HandleEncoder,
7668 T0: ::fidl_next::Encode<
7669 ::fidl_next::WireVector<'static, crate::wire::DictionaryOptionalItem<'static>>,
7670 ___E,
7671 >,
7672 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7673 {
7674 #[inline]
7675 fn encode(
7676 self,
7677 encoder_: &mut ___E,
7678 out_: &mut ::core::mem::MaybeUninit<
7679 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
7680 >,
7681 _: (),
7682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7683 ::fidl_next::munge! {
7684 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
7685
7686 items,
7687 end_id,
7688
7689 } = out_;
7690 }
7691
7692 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
7693
7694 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
7695
7696 Ok(())
7697 }
7698 }
7699
7700 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
7701 pub keys: T0,
7702 }
7703
7704 unsafe impl<___E, T0>
7705 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
7706 for DictionaryKeysIteratorGetNextResponse<T0>
7707 where
7708 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7709 ___E: ::fidl_next::Encoder,
7710 ___E: ::fidl_next::fuchsia::HandleEncoder,
7711 T0: ::fidl_next::Encode<
7712 ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
7713 ___E,
7714 >,
7715 {
7716 #[inline]
7717 fn encode(
7718 self,
7719 encoder_: &mut ___E,
7720 out_: &mut ::core::mem::MaybeUninit<
7721 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
7722 >,
7723 _: (),
7724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7725 ::fidl_next::munge! {
7726 let crate::wire::DictionaryKeysIteratorGetNextResponse {
7727
7728 keys,
7729
7730 } = out_;
7731 }
7732
7733 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
7734
7735 Ok(())
7736 }
7737 }
7738
7739 pub struct ProtocolPayload<T0> {
7740 pub channel: T0,
7741 }
7742
7743 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
7744 for ProtocolPayload<T0>
7745 where
7746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7747 ___E: ::fidl_next::fuchsia::HandleEncoder,
7748 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7749 {
7750 #[inline]
7751 fn encode(
7752 self,
7753 encoder_: &mut ___E,
7754 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
7755 _: (),
7756 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7757 ::fidl_next::munge! {
7758 let crate::wire::ProtocolPayload {
7759
7760 channel,
7761
7762 } = out_;
7763 }
7764
7765 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7766
7767 Ok(())
7768 }
7769 }
7770}
7771
7772pub use self::natural::*;
7773
7774#[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"]
7776#[derive(PartialEq, Debug)]
7777pub struct CapabilityStore;
7778
7779impl ::fidl_next::Discoverable for CapabilityStore {
7780 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
7781}
7782
7783#[cfg(target_os = "fuchsia")]
7784impl ::fidl_next::HasTransport for CapabilityStore {
7785 type Transport = ::fidl_next::fuchsia::zx::Channel;
7786}
7787
7788pub mod capability_store {
7789 pub mod prelude {
7790 pub use crate::{
7791 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
7792 capability_store,
7793 };
7794
7795 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
7796
7797 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
7798
7799 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
7800
7801 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
7802
7803 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
7804
7805 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
7806
7807 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
7808
7809 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
7810
7811 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
7812
7813 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
7814
7815 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
7816
7817 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
7818
7819 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
7820
7821 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
7822
7823 pub use crate::natural::CapabilityStoreDropRequest;
7824
7825 pub use crate::natural::CapabilityStoreDuplicateRequest;
7826
7827 pub use crate::natural::CapabilityStoreError;
7828
7829 pub use crate::natural::CapabilityStoreExportRequest;
7830
7831 pub use crate::natural::CapabilityStoreImportRequest;
7832
7833 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
7834
7835 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
7836
7837 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
7838
7839 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
7840
7841 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
7842
7843 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
7844
7845 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
7846
7847 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
7848
7849 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
7850
7851 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
7852
7853 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
7854
7855 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
7856
7857 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
7858
7859 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
7860
7861 pub use crate::natural::CapabilityStoreDropResponse;
7862
7863 pub use crate::natural::CapabilityStoreDuplicateResponse;
7864
7865 pub use crate::natural::CapabilityStoreExportResponse;
7866
7867 pub use crate::natural::CapabilityStoreImportResponse;
7868 }
7869
7870 pub struct Duplicate;
7871
7872 impl ::fidl_next::Method for Duplicate {
7873 const ORDINAL: u64 = 6727592627741008260;
7874 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7875 ::fidl_next::protocol::Flexibility::Flexible;
7876
7877 type Protocol = crate::CapabilityStore;
7878
7879 type Request = crate::wire::CapabilityStoreDuplicateRequest;
7880 }
7881
7882 impl ::fidl_next::TwoWayMethod for Duplicate {
7883 type Response = ::fidl_next::WireFlexibleResult<
7884 'static,
7885 crate::wire::CapabilityStoreDuplicateResponse,
7886 crate::wire::CapabilityStoreError,
7887 >;
7888 }
7889
7890 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
7891 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7892
7893 fn respond(response: ___R) -> Self::Output {
7894 ::fidl_next::FlexibleResult::Ok(response)
7895 }
7896 }
7897
7898 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
7899 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7900
7901 fn respond_err(response: ___R) -> Self::Output {
7902 ::fidl_next::FlexibleResult::Err(response)
7903 }
7904 }
7905
7906 pub struct Drop;
7907
7908 impl ::fidl_next::Method for Drop {
7909 const ORDINAL: u64 = 753328233834620249;
7910 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7911 ::fidl_next::protocol::Flexibility::Flexible;
7912
7913 type Protocol = crate::CapabilityStore;
7914
7915 type Request = crate::wire::CapabilityStoreDropRequest;
7916 }
7917
7918 impl ::fidl_next::TwoWayMethod for Drop {
7919 type Response = ::fidl_next::WireFlexibleResult<
7920 'static,
7921 crate::wire::CapabilityStoreDropResponse,
7922 crate::wire::CapabilityStoreError,
7923 >;
7924 }
7925
7926 impl<___R> ::fidl_next::Respond<___R> for Drop {
7927 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7928
7929 fn respond(response: ___R) -> Self::Output {
7930 ::fidl_next::FlexibleResult::Ok(response)
7931 }
7932 }
7933
7934 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
7935 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7936
7937 fn respond_err(response: ___R) -> Self::Output {
7938 ::fidl_next::FlexibleResult::Err(response)
7939 }
7940 }
7941
7942 pub struct Export;
7943
7944 impl ::fidl_next::Method for Export {
7945 const ORDINAL: u64 = 226159162093533951;
7946 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7947 ::fidl_next::protocol::Flexibility::Flexible;
7948
7949 type Protocol = crate::CapabilityStore;
7950
7951 type Request = crate::wire::CapabilityStoreExportRequest;
7952 }
7953
7954 impl ::fidl_next::TwoWayMethod for Export {
7955 type Response = ::fidl_next::WireFlexibleResult<
7956 'static,
7957 crate::wire::CapabilityStoreExportResponse<'static>,
7958 crate::wire::CapabilityStoreError,
7959 >;
7960 }
7961
7962 impl<___R> ::fidl_next::Respond<___R> for Export {
7963 type Output = ::fidl_next::FlexibleResult<
7964 crate::generic::CapabilityStoreExportResponse<___R>,
7965 ::fidl_next::util::Never,
7966 >;
7967
7968 fn respond(response: ___R) -> Self::Output {
7969 ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
7970 capability: response,
7971 })
7972 }
7973 }
7974
7975 impl<___R> ::fidl_next::RespondErr<___R> for Export {
7976 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7977
7978 fn respond_err(response: ___R) -> Self::Output {
7979 ::fidl_next::FlexibleResult::Err(response)
7980 }
7981 }
7982
7983 pub struct Import;
7984
7985 impl ::fidl_next::Method for Import {
7986 const ORDINAL: u64 = 2276030276116435867;
7987 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7988 ::fidl_next::protocol::Flexibility::Flexible;
7989
7990 type Protocol = crate::CapabilityStore;
7991
7992 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
7993 }
7994
7995 impl ::fidl_next::TwoWayMethod for Import {
7996 type Response = ::fidl_next::WireFlexibleResult<
7997 'static,
7998 crate::wire::CapabilityStoreImportResponse,
7999 crate::wire::CapabilityStoreError,
8000 >;
8001 }
8002
8003 impl<___R> ::fidl_next::Respond<___R> for Import {
8004 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8005
8006 fn respond(response: ___R) -> Self::Output {
8007 ::fidl_next::FlexibleResult::Ok(response)
8008 }
8009 }
8010
8011 impl<___R> ::fidl_next::RespondErr<___R> for Import {
8012 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8013
8014 fn respond_err(response: ___R) -> Self::Output {
8015 ::fidl_next::FlexibleResult::Err(response)
8016 }
8017 }
8018
8019 pub struct ConnectorCreate;
8020
8021 impl ::fidl_next::Method for ConnectorCreate {
8022 const ORDINAL: u64 = 2979461408102095909;
8023 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8024 ::fidl_next::protocol::Flexibility::Flexible;
8025
8026 type Protocol = crate::CapabilityStore;
8027
8028 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
8029 }
8030
8031 impl ::fidl_next::TwoWayMethod for ConnectorCreate {
8032 type Response = ::fidl_next::WireFlexibleResult<
8033 'static,
8034 crate::wire::CapabilityStoreConnectorCreateResponse,
8035 crate::wire::CapabilityStoreError,
8036 >;
8037 }
8038
8039 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
8040 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8041
8042 fn respond(response: ___R) -> Self::Output {
8043 ::fidl_next::FlexibleResult::Ok(response)
8044 }
8045 }
8046
8047 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
8048 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8049
8050 fn respond_err(response: ___R) -> Self::Output {
8051 ::fidl_next::FlexibleResult::Err(response)
8052 }
8053 }
8054
8055 pub struct ConnectorOpen;
8056
8057 impl ::fidl_next::Method for ConnectorOpen {
8058 const ORDINAL: u64 = 6016362336453278623;
8059 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8060 ::fidl_next::protocol::Flexibility::Flexible;
8061
8062 type Protocol = crate::CapabilityStore;
8063
8064 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
8065 }
8066
8067 impl ::fidl_next::TwoWayMethod for ConnectorOpen {
8068 type Response = ::fidl_next::WireFlexibleResult<
8069 'static,
8070 crate::wire::CapabilityStoreConnectorOpenResponse,
8071 crate::wire::CapabilityStoreError,
8072 >;
8073 }
8074
8075 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
8076 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8077
8078 fn respond(response: ___R) -> Self::Output {
8079 ::fidl_next::FlexibleResult::Ok(response)
8080 }
8081 }
8082
8083 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
8084 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8085
8086 fn respond_err(response: ___R) -> Self::Output {
8087 ::fidl_next::FlexibleResult::Err(response)
8088 }
8089 }
8090
8091 pub struct DirConnectorCreate;
8092
8093 impl ::fidl_next::Method for DirConnectorCreate {
8094 const ORDINAL: u64 = 1756747594275428795;
8095 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8096 ::fidl_next::protocol::Flexibility::Flexible;
8097
8098 type Protocol = crate::CapabilityStore;
8099
8100 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
8101 }
8102
8103 impl ::fidl_next::TwoWayMethod for DirConnectorCreate {
8104 type Response = ::fidl_next::WireFlexibleResult<
8105 'static,
8106 crate::wire::CapabilityStoreDirConnectorCreateResponse,
8107 crate::wire::CapabilityStoreError,
8108 >;
8109 }
8110
8111 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
8112 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8113
8114 fn respond(response: ___R) -> Self::Output {
8115 ::fidl_next::FlexibleResult::Ok(response)
8116 }
8117 }
8118
8119 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
8120 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8121
8122 fn respond_err(response: ___R) -> Self::Output {
8123 ::fidl_next::FlexibleResult::Err(response)
8124 }
8125 }
8126
8127 pub struct DirConnectorOpen;
8128
8129 impl ::fidl_next::Method for DirConnectorOpen {
8130 const ORDINAL: u64 = 6219704004220369153;
8131 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8132 ::fidl_next::protocol::Flexibility::Flexible;
8133
8134 type Protocol = crate::CapabilityStore;
8135
8136 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>;
8137 }
8138
8139 impl ::fidl_next::TwoWayMethod for DirConnectorOpen {
8140 type Response = ::fidl_next::WireFlexibleResult<
8141 'static,
8142 crate::wire::CapabilityStoreDirConnectorOpenResponse,
8143 crate::wire::CapabilityStoreError,
8144 >;
8145 }
8146
8147 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
8148 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8149
8150 fn respond(response: ___R) -> Self::Output {
8151 ::fidl_next::FlexibleResult::Ok(response)
8152 }
8153 }
8154
8155 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
8156 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8157
8158 fn respond_err(response: ___R) -> Self::Output {
8159 ::fidl_next::FlexibleResult::Err(response)
8160 }
8161 }
8162
8163 pub struct DictionaryCreate;
8164
8165 impl ::fidl_next::Method for DictionaryCreate {
8166 const ORDINAL: u64 = 7608770958894948499;
8167 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8168 ::fidl_next::protocol::Flexibility::Flexible;
8169
8170 type Protocol = crate::CapabilityStore;
8171
8172 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
8173 }
8174
8175 impl ::fidl_next::TwoWayMethod for DictionaryCreate {
8176 type Response = ::fidl_next::WireFlexibleResult<
8177 'static,
8178 crate::wire::CapabilityStoreDictionaryCreateResponse,
8179 crate::wire::CapabilityStoreError,
8180 >;
8181 }
8182
8183 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
8184 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8185
8186 fn respond(response: ___R) -> Self::Output {
8187 ::fidl_next::FlexibleResult::Ok(response)
8188 }
8189 }
8190
8191 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
8192 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8193
8194 fn respond_err(response: ___R) -> Self::Output {
8195 ::fidl_next::FlexibleResult::Err(response)
8196 }
8197 }
8198
8199 pub struct DictionaryLegacyImport;
8200
8201 impl ::fidl_next::Method for DictionaryLegacyImport {
8202 const ORDINAL: u64 = 8285893703432012383;
8203 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8204 ::fidl_next::protocol::Flexibility::Flexible;
8205
8206 type Protocol = crate::CapabilityStore;
8207
8208 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
8209 }
8210
8211 impl ::fidl_next::TwoWayMethod for DictionaryLegacyImport {
8212 type Response = ::fidl_next::WireFlexibleResult<
8213 'static,
8214 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
8215 crate::wire::CapabilityStoreError,
8216 >;
8217 }
8218
8219 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
8220 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8221
8222 fn respond(response: ___R) -> Self::Output {
8223 ::fidl_next::FlexibleResult::Ok(response)
8224 }
8225 }
8226
8227 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
8228 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8229
8230 fn respond_err(response: ___R) -> Self::Output {
8231 ::fidl_next::FlexibleResult::Err(response)
8232 }
8233 }
8234
8235 pub struct DictionaryLegacyExport;
8236
8237 impl ::fidl_next::Method for DictionaryLegacyExport {
8238 const ORDINAL: u64 = 4647175832683306445;
8239 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8240 ::fidl_next::protocol::Flexibility::Flexible;
8241
8242 type Protocol = crate::CapabilityStore;
8243
8244 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
8245 }
8246
8247 impl ::fidl_next::TwoWayMethod for DictionaryLegacyExport {
8248 type Response = ::fidl_next::WireFlexibleResult<
8249 'static,
8250 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
8251 crate::wire::CapabilityStoreError,
8252 >;
8253 }
8254
8255 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
8256 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8257
8258 fn respond(response: ___R) -> Self::Output {
8259 ::fidl_next::FlexibleResult::Ok(response)
8260 }
8261 }
8262
8263 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
8264 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8265
8266 fn respond_err(response: ___R) -> Self::Output {
8267 ::fidl_next::FlexibleResult::Err(response)
8268 }
8269 }
8270
8271 pub struct DictionaryInsert;
8272
8273 impl ::fidl_next::Method for DictionaryInsert {
8274 const ORDINAL: u64 = 8575443262986538023;
8275 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8276 ::fidl_next::protocol::Flexibility::Flexible;
8277
8278 type Protocol = crate::CapabilityStore;
8279
8280 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
8281 }
8282
8283 impl ::fidl_next::TwoWayMethod for DictionaryInsert {
8284 type Response = ::fidl_next::WireFlexibleResult<
8285 'static,
8286 crate::wire::CapabilityStoreDictionaryInsertResponse,
8287 crate::wire::CapabilityStoreError,
8288 >;
8289 }
8290
8291 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
8292 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8293
8294 fn respond(response: ___R) -> Self::Output {
8295 ::fidl_next::FlexibleResult::Ok(response)
8296 }
8297 }
8298
8299 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
8300 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8301
8302 fn respond_err(response: ___R) -> Self::Output {
8303 ::fidl_next::FlexibleResult::Err(response)
8304 }
8305 }
8306
8307 pub struct DictionaryGet;
8308
8309 impl ::fidl_next::Method for DictionaryGet {
8310 const ORDINAL: u64 = 5592951026866236882;
8311 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8312 ::fidl_next::protocol::Flexibility::Flexible;
8313
8314 type Protocol = crate::CapabilityStore;
8315
8316 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
8317 }
8318
8319 impl ::fidl_next::TwoWayMethod for DictionaryGet {
8320 type Response = ::fidl_next::WireFlexibleResult<
8321 'static,
8322 crate::wire::CapabilityStoreDictionaryGetResponse,
8323 crate::wire::CapabilityStoreError,
8324 >;
8325 }
8326
8327 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
8328 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8329
8330 fn respond(response: ___R) -> Self::Output {
8331 ::fidl_next::FlexibleResult::Ok(response)
8332 }
8333 }
8334
8335 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
8336 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8337
8338 fn respond_err(response: ___R) -> Self::Output {
8339 ::fidl_next::FlexibleResult::Err(response)
8340 }
8341 }
8342
8343 pub struct DictionaryRemove;
8344
8345 impl ::fidl_next::Method for DictionaryRemove {
8346 const ORDINAL: u64 = 343892214579320051;
8347 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8348 ::fidl_next::protocol::Flexibility::Flexible;
8349
8350 type Protocol = crate::CapabilityStore;
8351
8352 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
8353 }
8354
8355 impl ::fidl_next::TwoWayMethod for DictionaryRemove {
8356 type Response = ::fidl_next::WireFlexibleResult<
8357 'static,
8358 crate::wire::CapabilityStoreDictionaryRemoveResponse,
8359 crate::wire::CapabilityStoreError,
8360 >;
8361 }
8362
8363 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
8364 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8365
8366 fn respond(response: ___R) -> Self::Output {
8367 ::fidl_next::FlexibleResult::Ok(response)
8368 }
8369 }
8370
8371 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
8372 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8373
8374 fn respond_err(response: ___R) -> Self::Output {
8375 ::fidl_next::FlexibleResult::Err(response)
8376 }
8377 }
8378
8379 pub struct DictionaryCopy;
8380
8381 impl ::fidl_next::Method for DictionaryCopy {
8382 const ORDINAL: u64 = 3977783339739362383;
8383 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8384 ::fidl_next::protocol::Flexibility::Flexible;
8385
8386 type Protocol = crate::CapabilityStore;
8387
8388 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
8389 }
8390
8391 impl ::fidl_next::TwoWayMethod for DictionaryCopy {
8392 type Response = ::fidl_next::WireFlexibleResult<
8393 'static,
8394 crate::wire::CapabilityStoreDictionaryCopyResponse,
8395 crate::wire::CapabilityStoreError,
8396 >;
8397 }
8398
8399 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
8400 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8401
8402 fn respond(response: ___R) -> Self::Output {
8403 ::fidl_next::FlexibleResult::Ok(response)
8404 }
8405 }
8406
8407 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
8408 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8409
8410 fn respond_err(response: ___R) -> Self::Output {
8411 ::fidl_next::FlexibleResult::Err(response)
8412 }
8413 }
8414
8415 pub struct DictionaryKeys;
8416
8417 impl ::fidl_next::Method for DictionaryKeys {
8418 const ORDINAL: u64 = 597577248872787102;
8419 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8420 ::fidl_next::protocol::Flexibility::Flexible;
8421
8422 type Protocol = crate::CapabilityStore;
8423
8424 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
8425 }
8426
8427 impl ::fidl_next::TwoWayMethod for DictionaryKeys {
8428 type Response = ::fidl_next::WireFlexibleResult<
8429 'static,
8430 crate::wire::CapabilityStoreDictionaryKeysResponse,
8431 crate::wire::CapabilityStoreError,
8432 >;
8433 }
8434
8435 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
8436 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8437
8438 fn respond(response: ___R) -> Self::Output {
8439 ::fidl_next::FlexibleResult::Ok(response)
8440 }
8441 }
8442
8443 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
8444 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8445
8446 fn respond_err(response: ___R) -> Self::Output {
8447 ::fidl_next::FlexibleResult::Err(response)
8448 }
8449 }
8450
8451 pub struct DictionaryEnumerate;
8452
8453 impl ::fidl_next::Method for DictionaryEnumerate {
8454 const ORDINAL: u64 = 964467096271472193;
8455 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8456 ::fidl_next::protocol::Flexibility::Flexible;
8457
8458 type Protocol = crate::CapabilityStore;
8459
8460 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
8461 }
8462
8463 impl ::fidl_next::TwoWayMethod for DictionaryEnumerate {
8464 type Response = ::fidl_next::WireFlexibleResult<
8465 'static,
8466 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
8467 crate::wire::CapabilityStoreError,
8468 >;
8469 }
8470
8471 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
8472 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8473
8474 fn respond(response: ___R) -> Self::Output {
8475 ::fidl_next::FlexibleResult::Ok(response)
8476 }
8477 }
8478
8479 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
8480 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8481
8482 fn respond_err(response: ___R) -> Self::Output {
8483 ::fidl_next::FlexibleResult::Err(response)
8484 }
8485 }
8486
8487 pub struct DictionaryDrain;
8488
8489 impl ::fidl_next::Method for DictionaryDrain {
8490 const ORDINAL: u64 = 2928364469569621208;
8491 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8492 ::fidl_next::protocol::Flexibility::Flexible;
8493
8494 type Protocol = crate::CapabilityStore;
8495
8496 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
8497 }
8498
8499 impl ::fidl_next::TwoWayMethod for DictionaryDrain {
8500 type Response = ::fidl_next::WireFlexibleResult<
8501 'static,
8502 crate::wire::CapabilityStoreDictionaryDrainResponse,
8503 crate::wire::CapabilityStoreError,
8504 >;
8505 }
8506
8507 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
8508 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8509
8510 fn respond(response: ___R) -> Self::Output {
8511 ::fidl_next::FlexibleResult::Ok(response)
8512 }
8513 }
8514
8515 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
8516 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8517
8518 fn respond_err(response: ___R) -> Self::Output {
8519 ::fidl_next::FlexibleResult::Err(response)
8520 }
8521 }
8522
8523 mod ___detail {
8524 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
8525 where
8526 ___T: ::fidl_next::Transport,
8527 {
8528 type Client = CapabilityStoreClient<___T>;
8529 type Server = CapabilityStoreServer<___T>;
8530 }
8531
8532 #[repr(transparent)]
8534 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
8535 #[allow(dead_code)]
8536 client: ::fidl_next::protocol::Client<___T>,
8537 }
8538
8539 impl<___T> CapabilityStoreClient<___T>
8540 where
8541 ___T: ::fidl_next::Transport,
8542 {
8543 #[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"]
8544 pub fn duplicate(
8545 &self,
8546
8547 id: impl ::fidl_next::Encode<
8548 ::fidl_next::WireU64,
8549 <___T as ::fidl_next::Transport>::SendBuffer,
8550 >,
8551
8552 dest_id: impl ::fidl_next::Encode<
8553 ::fidl_next::WireU64,
8554 <___T as ::fidl_next::Transport>::SendBuffer,
8555 >,
8556 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
8557 where
8558 <___T as ::fidl_next::Transport>::SendBuffer:
8559 ::fidl_next::encoder::InternalHandleEncoder,
8560 {
8561 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
8562 }
8563
8564 #[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"]
8565 pub fn duplicate_with<___R>(
8566 &self,
8567 request: ___R,
8568 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
8569 where
8570 ___R: ::fidl_next::Encode<
8571 crate::wire::CapabilityStoreDuplicateRequest,
8572 <___T as ::fidl_next::Transport>::SendBuffer,
8573 >,
8574 {
8575 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8576 6727592627741008260,
8577 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
8578 request,
8579 ))
8580 }
8581
8582 #[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"]
8583 pub fn drop(
8584 &self,
8585
8586 id: impl ::fidl_next::Encode<
8587 ::fidl_next::WireU64,
8588 <___T as ::fidl_next::Transport>::SendBuffer,
8589 >,
8590 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
8591 where
8592 <___T as ::fidl_next::Transport>::SendBuffer:
8593 ::fidl_next::encoder::InternalHandleEncoder,
8594 {
8595 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
8596 }
8597
8598 #[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"]
8599 pub fn drop_with<___R>(
8600 &self,
8601 request: ___R,
8602 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
8603 where
8604 ___R: ::fidl_next::Encode<
8605 crate::wire::CapabilityStoreDropRequest,
8606 <___T as ::fidl_next::Transport>::SendBuffer,
8607 >,
8608 {
8609 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8610 753328233834620249,
8611 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
8612 request,
8613 ))
8614 }
8615
8616 #[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"]
8617 pub fn export(
8618 &self,
8619
8620 id: impl ::fidl_next::Encode<
8621 ::fidl_next::WireU64,
8622 <___T as ::fidl_next::Transport>::SendBuffer,
8623 >,
8624 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
8625 where
8626 <___T as ::fidl_next::Transport>::SendBuffer:
8627 ::fidl_next::encoder::InternalHandleEncoder,
8628 {
8629 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
8630 }
8631
8632 #[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"]
8633 pub fn export_with<___R>(
8634 &self,
8635 request: ___R,
8636 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
8637 where
8638 ___R: ::fidl_next::Encode<
8639 crate::wire::CapabilityStoreExportRequest,
8640 <___T as ::fidl_next::Transport>::SendBuffer,
8641 >,
8642 {
8643 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8644 226159162093533951,
8645 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
8646 request,
8647 ))
8648 }
8649
8650 #[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"]
8651 pub fn import(
8652 &self,
8653
8654 id: impl ::fidl_next::Encode<
8655 ::fidl_next::WireU64,
8656 <___T as ::fidl_next::Transport>::SendBuffer,
8657 >,
8658
8659 capability: impl ::fidl_next::Encode<
8660 crate::wire::Capability<'static>,
8661 <___T as ::fidl_next::Transport>::SendBuffer,
8662 >,
8663 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
8664 where
8665 <___T as ::fidl_next::Transport>::SendBuffer:
8666 ::fidl_next::encoder::InternalHandleEncoder,
8667 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8668 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8669 {
8670 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
8671 }
8672
8673 #[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"]
8674 pub fn import_with<___R>(
8675 &self,
8676 request: ___R,
8677 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
8678 where
8679 ___R: ::fidl_next::Encode<
8680 crate::wire::CapabilityStoreImportRequest<'static>,
8681 <___T as ::fidl_next::Transport>::SendBuffer,
8682 >,
8683 {
8684 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8685 2276030276116435867,
8686 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
8687 request,
8688 ))
8689 }
8690
8691 #[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"]
8692 pub fn connector_create(
8693 &self,
8694
8695 id: impl ::fidl_next::Encode<
8696 ::fidl_next::WireU64,
8697 <___T as ::fidl_next::Transport>::SendBuffer,
8698 >,
8699
8700 receiver: impl ::fidl_next::Encode<
8701 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
8702 <___T as ::fidl_next::Transport>::SendBuffer,
8703 >,
8704 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
8705 where
8706 <___T as ::fidl_next::Transport>::SendBuffer:
8707 ::fidl_next::encoder::InternalHandleEncoder,
8708 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8709 {
8710 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
8711 id,
8712
8713 receiver,
8714 })
8715 }
8716
8717 #[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"]
8718 pub fn connector_create_with<___R>(
8719 &self,
8720 request: ___R,
8721 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
8722 where
8723 ___R: ::fidl_next::Encode<
8724 crate::wire::CapabilityStoreConnectorCreateRequest,
8725 <___T as ::fidl_next::Transport>::SendBuffer,
8726 >,
8727 {
8728 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8729 2979461408102095909,
8730 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
8731 request,
8732 ))
8733 }
8734
8735 #[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"]
8736 pub fn connector_open(
8737 &self,
8738
8739 id: impl ::fidl_next::Encode<
8740 ::fidl_next::WireU64,
8741 <___T as ::fidl_next::Transport>::SendBuffer,
8742 >,
8743
8744 server_end: impl ::fidl_next::Encode<
8745 ::fidl_next::fuchsia::WireChannel,
8746 <___T as ::fidl_next::Transport>::SendBuffer,
8747 >,
8748 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
8749 where
8750 <___T as ::fidl_next::Transport>::SendBuffer:
8751 ::fidl_next::encoder::InternalHandleEncoder,
8752 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8753 {
8754 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
8755 id,
8756
8757 server_end,
8758 })
8759 }
8760
8761 #[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"]
8762 pub fn connector_open_with<___R>(
8763 &self,
8764 request: ___R,
8765 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
8766 where
8767 ___R: ::fidl_next::Encode<
8768 crate::wire::CapabilityStoreConnectorOpenRequest,
8769 <___T as ::fidl_next::Transport>::SendBuffer,
8770 >,
8771 {
8772 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8773 6016362336453278623,
8774 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
8775 request,
8776 ))
8777 }
8778
8779 #[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"]
8780 pub fn dir_connector_create(
8781 &self,
8782
8783 id: impl ::fidl_next::Encode<
8784 ::fidl_next::WireU64,
8785 <___T as ::fidl_next::Transport>::SendBuffer,
8786 >,
8787
8788 receiver: impl ::fidl_next::Encode<
8789 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
8790 <___T as ::fidl_next::Transport>::SendBuffer,
8791 >,
8792 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
8793 where
8794 <___T as ::fidl_next::Transport>::SendBuffer:
8795 ::fidl_next::encoder::InternalHandleEncoder,
8796 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8797 {
8798 self.dir_connector_create_with(
8799 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
8800 )
8801 }
8802
8803 #[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"]
8804 pub fn dir_connector_create_with<___R>(
8805 &self,
8806 request: ___R,
8807 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
8808 where
8809 ___R: ::fidl_next::Encode<
8810 crate::wire::CapabilityStoreDirConnectorCreateRequest,
8811 <___T as ::fidl_next::Transport>::SendBuffer,
8812 >,
8813 {
8814 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8815 1756747594275428795,
8816 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
8817 request,
8818 ))
8819 }
8820
8821 #[doc = " Open a connection from the provided [DirConnector] capability that will\n be dispatched to the [DirReceiver] on the other end. The `id` and\n `server_end` arguments are required, and the `flags` and `path`\n arguments are optional (a path of `.` will be used if one is not\n otherwise set).\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"]
8822 pub fn dir_connector_open_with<___R>(
8823 &self,
8824 request: ___R,
8825 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
8826 where
8827 ___R: ::fidl_next::Encode<
8828 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
8829 <___T as ::fidl_next::Transport>::SendBuffer,
8830 >,
8831 {
8832 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8833 6219704004220369153,
8834 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
8835 request,
8836 ))
8837 }
8838
8839 #[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"]
8840 pub fn dictionary_create(
8841 &self,
8842
8843 id: impl ::fidl_next::Encode<
8844 ::fidl_next::WireU64,
8845 <___T as ::fidl_next::Transport>::SendBuffer,
8846 >,
8847 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
8848 where
8849 <___T as ::fidl_next::Transport>::SendBuffer:
8850 ::fidl_next::encoder::InternalHandleEncoder,
8851 {
8852 self.dictionary_create_with(
8853 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
8854 )
8855 }
8856
8857 #[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"]
8858 pub fn dictionary_create_with<___R>(
8859 &self,
8860 request: ___R,
8861 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
8862 where
8863 ___R: ::fidl_next::Encode<
8864 crate::wire::CapabilityStoreDictionaryCreateRequest,
8865 <___T as ::fidl_next::Transport>::SendBuffer,
8866 >,
8867 {
8868 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8869 7608770958894948499,
8870 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
8871 request,
8872 ))
8873 }
8874
8875 #[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"]
8876 pub fn dictionary_legacy_import(
8877 &self,
8878
8879 id: impl ::fidl_next::Encode<
8880 ::fidl_next::WireU64,
8881 <___T as ::fidl_next::Transport>::SendBuffer,
8882 >,
8883
8884 client_end: impl ::fidl_next::Encode<
8885 ::fidl_next::fuchsia::WireChannel,
8886 <___T as ::fidl_next::Transport>::SendBuffer,
8887 >,
8888 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
8889 where
8890 <___T as ::fidl_next::Transport>::SendBuffer:
8891 ::fidl_next::encoder::InternalHandleEncoder,
8892 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8893 {
8894 self.dictionary_legacy_import_with(
8895 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
8896 )
8897 }
8898
8899 #[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"]
8900 pub fn dictionary_legacy_import_with<___R>(
8901 &self,
8902 request: ___R,
8903 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
8904 where
8905 ___R: ::fidl_next::Encode<
8906 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
8907 <___T as ::fidl_next::Transport>::SendBuffer,
8908 >,
8909 {
8910 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8911 8285893703432012383,
8912 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
8913 request,
8914 ))
8915 }
8916
8917 #[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"]
8918 pub fn dictionary_legacy_export(
8919 &self,
8920
8921 id: impl ::fidl_next::Encode<
8922 ::fidl_next::WireU64,
8923 <___T as ::fidl_next::Transport>::SendBuffer,
8924 >,
8925
8926 server_end: impl ::fidl_next::Encode<
8927 ::fidl_next::fuchsia::WireChannel,
8928 <___T as ::fidl_next::Transport>::SendBuffer,
8929 >,
8930 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
8931 where
8932 <___T as ::fidl_next::Transport>::SendBuffer:
8933 ::fidl_next::encoder::InternalHandleEncoder,
8934 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8935 {
8936 self.dictionary_legacy_export_with(
8937 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
8938 )
8939 }
8940
8941 #[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"]
8942 pub fn dictionary_legacy_export_with<___R>(
8943 &self,
8944 request: ___R,
8945 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
8946 where
8947 ___R: ::fidl_next::Encode<
8948 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
8949 <___T as ::fidl_next::Transport>::SendBuffer,
8950 >,
8951 {
8952 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8953 4647175832683306445,
8954 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
8955 request,
8956 ))
8957 }
8958
8959 #[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"]
8960 pub fn dictionary_insert(
8961 &self,
8962
8963 id: impl ::fidl_next::Encode<
8964 ::fidl_next::WireU64,
8965 <___T as ::fidl_next::Transport>::SendBuffer,
8966 >,
8967
8968 item: impl ::fidl_next::Encode<
8969 crate::wire::DictionaryItem<'static>,
8970 <___T as ::fidl_next::Transport>::SendBuffer,
8971 >,
8972 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8973 where
8974 <___T as ::fidl_next::Transport>::SendBuffer:
8975 ::fidl_next::encoder::InternalHandleEncoder,
8976 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8977 {
8978 self.dictionary_insert_with(
8979 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
8980 )
8981 }
8982
8983 #[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"]
8984 pub fn dictionary_insert_with<___R>(
8985 &self,
8986 request: ___R,
8987 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8988 where
8989 ___R: ::fidl_next::Encode<
8990 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
8991 <___T as ::fidl_next::Transport>::SendBuffer,
8992 >,
8993 {
8994 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8995 8575443262986538023,
8996 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
8997 request,
8998 ))
8999 }
9000
9001 #[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"]
9002 pub fn dictionary_get(
9003 &self,
9004
9005 id: impl ::fidl_next::Encode<
9006 ::fidl_next::WireU64,
9007 <___T as ::fidl_next::Transport>::SendBuffer,
9008 >,
9009
9010 key: impl ::fidl_next::Encode<
9011 ::fidl_next::WireString<'static>,
9012 <___T as ::fidl_next::Transport>::SendBuffer,
9013 >,
9014
9015 dest_id: impl ::fidl_next::Encode<
9016 ::fidl_next::WireU64,
9017 <___T as ::fidl_next::Transport>::SendBuffer,
9018 >,
9019 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
9020 where
9021 <___T as ::fidl_next::Transport>::SendBuffer:
9022 ::fidl_next::encoder::InternalHandleEncoder,
9023 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9024 {
9025 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
9026 id,
9027
9028 key,
9029
9030 dest_id,
9031 })
9032 }
9033
9034 #[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"]
9035 pub fn dictionary_get_with<___R>(
9036 &self,
9037 request: ___R,
9038 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
9039 where
9040 ___R: ::fidl_next::Encode<
9041 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
9042 <___T as ::fidl_next::Transport>::SendBuffer,
9043 >,
9044 {
9045 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9046 5592951026866236882,
9047 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
9048 request,
9049 ))
9050 }
9051
9052 #[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"]
9053 pub fn dictionary_remove(
9054 &self,
9055
9056 id: impl ::fidl_next::Encode<
9057 ::fidl_next::WireU64,
9058 <___T as ::fidl_next::Transport>::SendBuffer,
9059 >,
9060
9061 key: impl ::fidl_next::Encode<
9062 ::fidl_next::WireString<'static>,
9063 <___T as ::fidl_next::Transport>::SendBuffer,
9064 >,
9065
9066 dest_id: impl ::fidl_next::Encode<
9067 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
9068 <___T as ::fidl_next::Transport>::SendBuffer,
9069 >,
9070 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
9071 where
9072 <___T as ::fidl_next::Transport>::SendBuffer:
9073 ::fidl_next::encoder::InternalHandleEncoder,
9074 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9075 {
9076 self.dictionary_remove_with(
9077 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
9078 )
9079 }
9080
9081 #[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"]
9082 pub fn dictionary_remove_with<___R>(
9083 &self,
9084 request: ___R,
9085 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
9086 where
9087 ___R: ::fidl_next::Encode<
9088 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
9089 <___T as ::fidl_next::Transport>::SendBuffer,
9090 >,
9091 {
9092 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9093 343892214579320051,
9094 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
9095 request,
9096 ))
9097 }
9098
9099 #[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"]
9100 pub fn dictionary_copy(
9101 &self,
9102
9103 id: impl ::fidl_next::Encode<
9104 ::fidl_next::WireU64,
9105 <___T as ::fidl_next::Transport>::SendBuffer,
9106 >,
9107
9108 dest_id: impl ::fidl_next::Encode<
9109 ::fidl_next::WireU64,
9110 <___T as ::fidl_next::Transport>::SendBuffer,
9111 >,
9112 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
9113 where
9114 <___T as ::fidl_next::Transport>::SendBuffer:
9115 ::fidl_next::encoder::InternalHandleEncoder,
9116 {
9117 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
9118 id,
9119
9120 dest_id,
9121 })
9122 }
9123
9124 #[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"]
9125 pub fn dictionary_copy_with<___R>(
9126 &self,
9127 request: ___R,
9128 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
9129 where
9130 ___R: ::fidl_next::Encode<
9131 crate::wire::CapabilityStoreDictionaryCopyRequest,
9132 <___T as ::fidl_next::Transport>::SendBuffer,
9133 >,
9134 {
9135 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9136 3977783339739362383,
9137 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
9138 request,
9139 ))
9140 }
9141
9142 #[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"]
9143 pub fn dictionary_keys(
9144 &self,
9145
9146 id: impl ::fidl_next::Encode<
9147 ::fidl_next::WireU64,
9148 <___T as ::fidl_next::Transport>::SendBuffer,
9149 >,
9150
9151 iterator: impl ::fidl_next::Encode<
9152 ::fidl_next::ServerEnd<
9153 crate::DictionaryKeysIterator,
9154 ::fidl_next::fuchsia::WireChannel,
9155 >,
9156 <___T as ::fidl_next::Transport>::SendBuffer,
9157 >,
9158 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9159 where
9160 <___T as ::fidl_next::Transport>::SendBuffer:
9161 ::fidl_next::encoder::InternalHandleEncoder,
9162 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9163 {
9164 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
9165 id,
9166
9167 iterator,
9168 })
9169 }
9170
9171 #[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"]
9172 pub fn dictionary_keys_with<___R>(
9173 &self,
9174 request: ___R,
9175 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9176 where
9177 ___R: ::fidl_next::Encode<
9178 crate::wire::CapabilityStoreDictionaryKeysRequest,
9179 <___T as ::fidl_next::Transport>::SendBuffer,
9180 >,
9181 {
9182 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9183 597577248872787102,
9184 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
9185 request,
9186 ))
9187 }
9188
9189 #[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"]
9190 pub fn dictionary_enumerate(
9191 &self,
9192
9193 id: impl ::fidl_next::Encode<
9194 ::fidl_next::WireU64,
9195 <___T as ::fidl_next::Transport>::SendBuffer,
9196 >,
9197
9198 iterator: impl ::fidl_next::Encode<
9199 ::fidl_next::ServerEnd<
9200 crate::DictionaryEnumerateIterator,
9201 ::fidl_next::fuchsia::WireChannel,
9202 >,
9203 <___T as ::fidl_next::Transport>::SendBuffer,
9204 >,
9205 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9206 where
9207 <___T as ::fidl_next::Transport>::SendBuffer:
9208 ::fidl_next::encoder::InternalHandleEncoder,
9209 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9210 {
9211 self.dictionary_enumerate_with(
9212 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
9213 )
9214 }
9215
9216 #[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"]
9217 pub fn dictionary_enumerate_with<___R>(
9218 &self,
9219 request: ___R,
9220 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9221 where
9222 ___R: ::fidl_next::Encode<
9223 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
9224 <___T as ::fidl_next::Transport>::SendBuffer,
9225 >,
9226 {
9227 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9228 964467096271472193,
9229 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
9230 request,
9231 ))
9232 }
9233
9234 #[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"]
9235 pub fn dictionary_drain(
9236 &self,
9237
9238 id: impl ::fidl_next::Encode<
9239 ::fidl_next::WireU64,
9240 <___T as ::fidl_next::Transport>::SendBuffer,
9241 >,
9242
9243 iterator: impl ::fidl_next::Encode<
9244 ::fidl_next::ServerEnd<
9245 crate::DictionaryDrainIterator,
9246 ::fidl_next::fuchsia::WireOptionalChannel,
9247 >,
9248 <___T as ::fidl_next::Transport>::SendBuffer,
9249 >,
9250 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
9251 where
9252 <___T as ::fidl_next::Transport>::SendBuffer:
9253 ::fidl_next::encoder::InternalHandleEncoder,
9254 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9255 {
9256 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
9257 id,
9258
9259 iterator,
9260 })
9261 }
9262
9263 #[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"]
9264 pub fn dictionary_drain_with<___R>(
9265 &self,
9266 request: ___R,
9267 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
9268 where
9269 ___R: ::fidl_next::Encode<
9270 crate::wire::CapabilityStoreDictionaryDrainRequest,
9271 <___T as ::fidl_next::Transport>::SendBuffer,
9272 >,
9273 {
9274 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9275 2928364469569621208,
9276 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
9277 request,
9278 ))
9279 }
9280 }
9281
9282 #[repr(transparent)]
9284 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
9285 server: ::fidl_next::protocol::Server<___T>,
9286 }
9287
9288 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
9289 }
9290}
9291
9292pub trait CapabilityStoreClientHandler<
9296 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9297 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9298>
9299{
9300 fn on_unknown_interaction(
9301 &mut self,
9302 ordinal: u64,
9303 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9304 ::core::future::ready(())
9305 }
9306}
9307
9308impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
9309where
9310 ___T: ::fidl_next::Transport,
9311{
9312 async fn on_unknown_interaction(&mut self, _: u64) {}
9313}
9314
9315impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
9316where
9317 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
9318 ___T: ::fidl_next::Transport,
9319{
9320 async fn on_event(
9321 handler: &mut ___H,
9322 ordinal: u64,
9323 flexibility: ::fidl_next::protocol::Flexibility,
9324 buffer: ___T::RecvBuffer,
9325 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9326 match ordinal {
9327 ordinal => {
9328 handler.on_unknown_interaction(ordinal).await;
9329 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9330 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9331 } else {
9332 Ok(())
9333 }
9334 }
9335 }
9336 }
9337}
9338
9339pub trait CapabilityStoreServerHandler<
9343 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9344 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9345>
9346{
9347 #[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"]
9348 fn duplicate(
9349 &mut self,
9350
9351 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
9352
9353 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
9354 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9355
9356 #[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"]
9357 fn drop(
9358 &mut self,
9359
9360 request: ::fidl_next::Request<capability_store::Drop, ___T>,
9361
9362 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
9363 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9364
9365 #[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"]
9366 fn export(
9367 &mut self,
9368
9369 request: ::fidl_next::Request<capability_store::Export, ___T>,
9370
9371 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
9372 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9373
9374 #[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"]
9375 fn import(
9376 &mut self,
9377
9378 request: ::fidl_next::Request<capability_store::Import, ___T>,
9379
9380 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
9381 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9382
9383 #[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"]
9384 fn connector_create(
9385 &mut self,
9386
9387 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
9388
9389 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
9390 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9391
9392 #[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"]
9393 fn connector_open(
9394 &mut self,
9395
9396 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
9397
9398 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
9399 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9400
9401 #[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"]
9402 fn dir_connector_create(
9403 &mut self,
9404
9405 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
9406
9407 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
9408 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9409
9410 #[doc = " Open a connection from the provided [DirConnector] capability that will\n be dispatched to the [DirReceiver] on the other end. The `id` and\n `server_end` arguments are required, and the `flags` and `path`\n arguments are optional (a path of `.` will be used if one is not\n otherwise set).\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"]
9411 fn dir_connector_open(
9412 &mut self,
9413
9414 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
9415
9416 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
9417 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9418
9419 #[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"]
9420 fn dictionary_create(
9421 &mut self,
9422
9423 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
9424
9425 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
9426 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9427
9428 #[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"]
9429 fn dictionary_legacy_import(
9430 &mut self,
9431
9432 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
9433
9434 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
9435 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9436
9437 #[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"]
9438 fn dictionary_legacy_export(
9439 &mut self,
9440
9441 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
9442
9443 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
9444 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9445
9446 #[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"]
9447 fn dictionary_insert(
9448 &mut self,
9449
9450 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
9451
9452 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
9453 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9454
9455 #[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"]
9456 fn dictionary_get(
9457 &mut self,
9458
9459 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
9460
9461 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
9462 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9463
9464 #[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"]
9465 fn dictionary_remove(
9466 &mut self,
9467
9468 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
9469
9470 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
9471 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9472
9473 #[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"]
9474 fn dictionary_copy(
9475 &mut self,
9476
9477 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
9478
9479 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
9480 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9481
9482 #[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"]
9483 fn dictionary_keys(
9484 &mut self,
9485
9486 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
9487
9488 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
9489 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9490
9491 #[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"]
9492 fn dictionary_enumerate(
9493 &mut self,
9494
9495 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
9496
9497 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
9498 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9499
9500 #[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"]
9501 fn dictionary_drain(
9502 &mut self,
9503
9504 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
9505
9506 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
9507 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9508
9509 fn on_unknown_interaction(
9510 &mut self,
9511 ordinal: u64,
9512 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9513 ::core::future::ready(())
9514 }
9515}
9516
9517impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
9518where
9519 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
9520 ___T: ::fidl_next::Transport,
9521 <capability_store::Duplicate as ::fidl_next::Method>::Request:
9522 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9523 <capability_store::Drop as ::fidl_next::Method>::Request:
9524 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9525 <capability_store::Export as ::fidl_next::Method>::Request:
9526 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9527 <capability_store::Import as ::fidl_next::Method>::Request:
9528 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9529 <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
9530 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9531 <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
9532 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9533 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
9534 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9535 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
9536 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9537 <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
9538 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9539 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
9540 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9541 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
9542 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9543 <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
9544 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9545 <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
9546 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9547 <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
9548 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9549 <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
9550 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9551 <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
9552 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9553 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
9554 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9555 <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
9556 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9557{
9558 async fn on_one_way(
9559 handler: &mut ___H,
9560 ordinal: u64,
9561 flexibility: ::fidl_next::protocol::Flexibility,
9562 buffer: ___T::RecvBuffer,
9563 ) -> ::core::result::Result<
9564 (),
9565 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9566 > {
9567 match ordinal {
9568 ordinal => {
9569 handler.on_unknown_interaction(ordinal).await;
9570 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9571 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9572 } else {
9573 Ok(())
9574 }
9575 }
9576 }
9577 }
9578
9579 async fn on_two_way(
9580 handler: &mut ___H,
9581 ordinal: u64,
9582 flexibility: ::fidl_next::protocol::Flexibility,
9583 buffer: ___T::RecvBuffer,
9584 responder: ::fidl_next::protocol::Responder<___T>,
9585 ) -> ::core::result::Result<
9586 (),
9587 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9588 > {
9589 match ordinal {
9590 6727592627741008260 => {
9591 let responder = ::fidl_next::Responder::from_untyped(responder);
9592
9593 match ::fidl_next::DecoderExt::decode(buffer) {
9594 Ok(decoded) => {
9595 handler
9596 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
9597 .await;
9598 Ok(())
9599 }
9600 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9601 ordinal: 6727592627741008260,
9602 error,
9603 }),
9604 }
9605 }
9606
9607 753328233834620249 => {
9608 let responder = ::fidl_next::Responder::from_untyped(responder);
9609
9610 match ::fidl_next::DecoderExt::decode(buffer) {
9611 Ok(decoded) => {
9612 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
9613 Ok(())
9614 }
9615 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9616 ordinal: 753328233834620249,
9617 error,
9618 }),
9619 }
9620 }
9621
9622 226159162093533951 => {
9623 let responder = ::fidl_next::Responder::from_untyped(responder);
9624
9625 match ::fidl_next::DecoderExt::decode(buffer) {
9626 Ok(decoded) => {
9627 handler
9628 .export(::fidl_next::Request::from_decoded(decoded), responder)
9629 .await;
9630 Ok(())
9631 }
9632 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9633 ordinal: 226159162093533951,
9634 error,
9635 }),
9636 }
9637 }
9638
9639 2276030276116435867 => {
9640 let responder = ::fidl_next::Responder::from_untyped(responder);
9641
9642 match ::fidl_next::DecoderExt::decode(buffer) {
9643 Ok(decoded) => {
9644 handler
9645 .import(::fidl_next::Request::from_decoded(decoded), responder)
9646 .await;
9647 Ok(())
9648 }
9649 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9650 ordinal: 2276030276116435867,
9651 error,
9652 }),
9653 }
9654 }
9655
9656 2979461408102095909 => {
9657 let responder = ::fidl_next::Responder::from_untyped(responder);
9658
9659 match ::fidl_next::DecoderExt::decode(buffer) {
9660 Ok(decoded) => {
9661 handler
9662 .connector_create(
9663 ::fidl_next::Request::from_decoded(decoded),
9664 responder,
9665 )
9666 .await;
9667 Ok(())
9668 }
9669 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9670 ordinal: 2979461408102095909,
9671 error,
9672 }),
9673 }
9674 }
9675
9676 6016362336453278623 => {
9677 let responder = ::fidl_next::Responder::from_untyped(responder);
9678
9679 match ::fidl_next::DecoderExt::decode(buffer) {
9680 Ok(decoded) => {
9681 handler
9682 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
9683 .await;
9684 Ok(())
9685 }
9686 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9687 ordinal: 6016362336453278623,
9688 error,
9689 }),
9690 }
9691 }
9692
9693 1756747594275428795 => {
9694 let responder = ::fidl_next::Responder::from_untyped(responder);
9695
9696 match ::fidl_next::DecoderExt::decode(buffer) {
9697 Ok(decoded) => {
9698 handler
9699 .dir_connector_create(
9700 ::fidl_next::Request::from_decoded(decoded),
9701 responder,
9702 )
9703 .await;
9704 Ok(())
9705 }
9706 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9707 ordinal: 1756747594275428795,
9708 error,
9709 }),
9710 }
9711 }
9712
9713 6219704004220369153 => {
9714 let responder = ::fidl_next::Responder::from_untyped(responder);
9715
9716 match ::fidl_next::DecoderExt::decode(buffer) {
9717 Ok(decoded) => {
9718 handler
9719 .dir_connector_open(
9720 ::fidl_next::Request::from_decoded(decoded),
9721 responder,
9722 )
9723 .await;
9724 Ok(())
9725 }
9726 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9727 ordinal: 6219704004220369153,
9728 error,
9729 }),
9730 }
9731 }
9732
9733 7608770958894948499 => {
9734 let responder = ::fidl_next::Responder::from_untyped(responder);
9735
9736 match ::fidl_next::DecoderExt::decode(buffer) {
9737 Ok(decoded) => {
9738 handler
9739 .dictionary_create(
9740 ::fidl_next::Request::from_decoded(decoded),
9741 responder,
9742 )
9743 .await;
9744 Ok(())
9745 }
9746 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9747 ordinal: 7608770958894948499,
9748 error,
9749 }),
9750 }
9751 }
9752
9753 8285893703432012383 => {
9754 let responder = ::fidl_next::Responder::from_untyped(responder);
9755
9756 match ::fidl_next::DecoderExt::decode(buffer) {
9757 Ok(decoded) => {
9758 handler
9759 .dictionary_legacy_import(
9760 ::fidl_next::Request::from_decoded(decoded),
9761 responder,
9762 )
9763 .await;
9764 Ok(())
9765 }
9766 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9767 ordinal: 8285893703432012383,
9768 error,
9769 }),
9770 }
9771 }
9772
9773 4647175832683306445 => {
9774 let responder = ::fidl_next::Responder::from_untyped(responder);
9775
9776 match ::fidl_next::DecoderExt::decode(buffer) {
9777 Ok(decoded) => {
9778 handler
9779 .dictionary_legacy_export(
9780 ::fidl_next::Request::from_decoded(decoded),
9781 responder,
9782 )
9783 .await;
9784 Ok(())
9785 }
9786 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9787 ordinal: 4647175832683306445,
9788 error,
9789 }),
9790 }
9791 }
9792
9793 8575443262986538023 => {
9794 let responder = ::fidl_next::Responder::from_untyped(responder);
9795
9796 match ::fidl_next::DecoderExt::decode(buffer) {
9797 Ok(decoded) => {
9798 handler
9799 .dictionary_insert(
9800 ::fidl_next::Request::from_decoded(decoded),
9801 responder,
9802 )
9803 .await;
9804 Ok(())
9805 }
9806 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9807 ordinal: 8575443262986538023,
9808 error,
9809 }),
9810 }
9811 }
9812
9813 5592951026866236882 => {
9814 let responder = ::fidl_next::Responder::from_untyped(responder);
9815
9816 match ::fidl_next::DecoderExt::decode(buffer) {
9817 Ok(decoded) => {
9818 handler
9819 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
9820 .await;
9821 Ok(())
9822 }
9823 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9824 ordinal: 5592951026866236882,
9825 error,
9826 }),
9827 }
9828 }
9829
9830 343892214579320051 => {
9831 let responder = ::fidl_next::Responder::from_untyped(responder);
9832
9833 match ::fidl_next::DecoderExt::decode(buffer) {
9834 Ok(decoded) => {
9835 handler
9836 .dictionary_remove(
9837 ::fidl_next::Request::from_decoded(decoded),
9838 responder,
9839 )
9840 .await;
9841 Ok(())
9842 }
9843 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9844 ordinal: 343892214579320051,
9845 error,
9846 }),
9847 }
9848 }
9849
9850 3977783339739362383 => {
9851 let responder = ::fidl_next::Responder::from_untyped(responder);
9852
9853 match ::fidl_next::DecoderExt::decode(buffer) {
9854 Ok(decoded) => {
9855 handler
9856 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
9857 .await;
9858 Ok(())
9859 }
9860 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9861 ordinal: 3977783339739362383,
9862 error,
9863 }),
9864 }
9865 }
9866
9867 597577248872787102 => {
9868 let responder = ::fidl_next::Responder::from_untyped(responder);
9869
9870 match ::fidl_next::DecoderExt::decode(buffer) {
9871 Ok(decoded) => {
9872 handler
9873 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
9874 .await;
9875 Ok(())
9876 }
9877 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9878 ordinal: 597577248872787102,
9879 error,
9880 }),
9881 }
9882 }
9883
9884 964467096271472193 => {
9885 let responder = ::fidl_next::Responder::from_untyped(responder);
9886
9887 match ::fidl_next::DecoderExt::decode(buffer) {
9888 Ok(decoded) => {
9889 handler
9890 .dictionary_enumerate(
9891 ::fidl_next::Request::from_decoded(decoded),
9892 responder,
9893 )
9894 .await;
9895 Ok(())
9896 }
9897 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9898 ordinal: 964467096271472193,
9899 error,
9900 }),
9901 }
9902 }
9903
9904 2928364469569621208 => {
9905 let responder = ::fidl_next::Responder::from_untyped(responder);
9906
9907 match ::fidl_next::DecoderExt::decode(buffer) {
9908 Ok(decoded) => {
9909 handler
9910 .dictionary_drain(
9911 ::fidl_next::Request::from_decoded(decoded),
9912 responder,
9913 )
9914 .await;
9915 Ok(())
9916 }
9917 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9918 ordinal: 2928364469569621208,
9919 error,
9920 }),
9921 }
9922 }
9923
9924 ordinal => {
9925 handler.on_unknown_interaction(ordinal).await;
9926 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9927 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9928 } else {
9929 responder
9930 .respond(
9931 ordinal,
9932 flexibility,
9933 ::fidl_next::Flexible::<()>::FrameworkErr(
9934 ::fidl_next::FrameworkError::UnknownMethod,
9935 ),
9936 )
9937 .expect("encoding a framework error should never fail")
9938 .await?;
9939 Ok(())
9940 }
9941 }
9942 }
9943 }
9944}
9945
9946#[derive(PartialEq, Debug)]
9948pub struct ConnectorRouter;
9949
9950impl ::fidl_next::Discoverable for ConnectorRouter {
9951 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
9952}
9953
9954#[cfg(target_os = "fuchsia")]
9955impl ::fidl_next::HasTransport for ConnectorRouter {
9956 type Transport = ::fidl_next::fuchsia::zx::Channel;
9957}
9958
9959pub mod connector_router {
9960 pub mod prelude {
9961 pub use crate::{
9962 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
9963 connector_router,
9964 };
9965
9966 pub use crate::natural::ConnectorRouterRouteResponse;
9967
9968 pub use crate::natural::RouteRequest;
9969
9970 pub use crate::natural::RouterError;
9971 }
9972
9973 pub struct Route;
9974
9975 impl ::fidl_next::Method for Route {
9976 const ORDINAL: u64 = 8420527046218942310;
9977 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9978 ::fidl_next::protocol::Flexibility::Flexible;
9979
9980 type Protocol = crate::ConnectorRouter;
9981
9982 type Request = crate::wire::RouteRequest<'static>;
9983 }
9984
9985 impl ::fidl_next::TwoWayMethod for Route {
9986 type Response = ::fidl_next::WireFlexibleResult<
9987 'static,
9988 crate::wire::ConnectorRouterRouteResponse,
9989 crate::wire::RouterError,
9990 >;
9991 }
9992
9993 impl<___R> ::fidl_next::Respond<___R> for Route {
9994 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9995
9996 fn respond(response: ___R) -> Self::Output {
9997 ::fidl_next::FlexibleResult::Ok(response)
9998 }
9999 }
10000
10001 impl<___R> ::fidl_next::RespondErr<___R> for Route {
10002 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10003
10004 fn respond_err(response: ___R) -> Self::Output {
10005 ::fidl_next::FlexibleResult::Err(response)
10006 }
10007 }
10008
10009 mod ___detail {
10010 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
10011 where
10012 ___T: ::fidl_next::Transport,
10013 {
10014 type Client = ConnectorRouterClient<___T>;
10015 type Server = ConnectorRouterServer<___T>;
10016 }
10017
10018 #[repr(transparent)]
10020 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
10021 #[allow(dead_code)]
10022 client: ::fidl_next::protocol::Client<___T>,
10023 }
10024
10025 impl<___T> ConnectorRouterClient<___T>
10026 where
10027 ___T: ::fidl_next::Transport,
10028 {
10029 pub fn route_with<___R>(
10030 &self,
10031 request: ___R,
10032 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10033 where
10034 ___R: ::fidl_next::Encode<
10035 crate::wire::RouteRequest<'static>,
10036 <___T as ::fidl_next::Transport>::SendBuffer,
10037 >,
10038 {
10039 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10040 8420527046218942310,
10041 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
10042 request,
10043 ))
10044 }
10045 }
10046
10047 #[repr(transparent)]
10049 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
10050 server: ::fidl_next::protocol::Server<___T>,
10051 }
10052
10053 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
10054 }
10055}
10056
10057pub trait ConnectorRouterClientHandler<
10061 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10062 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10063>
10064{
10065 fn on_unknown_interaction(
10066 &mut self,
10067 ordinal: u64,
10068 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10069 ::core::future::ready(())
10070 }
10071}
10072
10073impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
10074where
10075 ___T: ::fidl_next::Transport,
10076{
10077 async fn on_unknown_interaction(&mut self, _: u64) {}
10078}
10079
10080impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
10081where
10082 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
10083 ___T: ::fidl_next::Transport,
10084{
10085 async fn on_event(
10086 handler: &mut ___H,
10087 ordinal: u64,
10088 flexibility: ::fidl_next::protocol::Flexibility,
10089 buffer: ___T::RecvBuffer,
10090 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10091 match ordinal {
10092 ordinal => {
10093 handler.on_unknown_interaction(ordinal).await;
10094 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10095 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10096 } else {
10097 Ok(())
10098 }
10099 }
10100 }
10101 }
10102}
10103
10104pub trait ConnectorRouterServerHandler<
10108 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10109 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10110>
10111{
10112 fn route(
10113 &mut self,
10114
10115 request: ::fidl_next::Request<connector_router::Route, ___T>,
10116
10117 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
10118 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10119
10120 fn on_unknown_interaction(
10121 &mut self,
10122 ordinal: u64,
10123 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10124 ::core::future::ready(())
10125 }
10126}
10127
10128impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
10129where
10130 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
10131 ___T: ::fidl_next::Transport,
10132 <connector_router::Route as ::fidl_next::Method>::Request:
10133 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10134{
10135 async fn on_one_way(
10136 handler: &mut ___H,
10137 ordinal: u64,
10138 flexibility: ::fidl_next::protocol::Flexibility,
10139 buffer: ___T::RecvBuffer,
10140 ) -> ::core::result::Result<
10141 (),
10142 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10143 > {
10144 match ordinal {
10145 ordinal => {
10146 handler.on_unknown_interaction(ordinal).await;
10147 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10148 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10149 } else {
10150 Ok(())
10151 }
10152 }
10153 }
10154 }
10155
10156 async fn on_two_way(
10157 handler: &mut ___H,
10158 ordinal: u64,
10159 flexibility: ::fidl_next::protocol::Flexibility,
10160 buffer: ___T::RecvBuffer,
10161 responder: ::fidl_next::protocol::Responder<___T>,
10162 ) -> ::core::result::Result<
10163 (),
10164 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10165 > {
10166 match ordinal {
10167 8420527046218942310 => {
10168 let responder = ::fidl_next::Responder::from_untyped(responder);
10169
10170 match ::fidl_next::DecoderExt::decode(buffer) {
10171 Ok(decoded) => {
10172 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
10173 Ok(())
10174 }
10175 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10176 ordinal: 8420527046218942310,
10177 error,
10178 }),
10179 }
10180 }
10181
10182 ordinal => {
10183 handler.on_unknown_interaction(ordinal).await;
10184 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10185 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10186 } else {
10187 responder
10188 .respond(
10189 ordinal,
10190 flexibility,
10191 ::fidl_next::Flexible::<()>::FrameworkErr(
10192 ::fidl_next::FrameworkError::UnknownMethod,
10193 ),
10194 )
10195 .expect("encoding a framework error should never fail")
10196 .await?;
10197 Ok(())
10198 }
10199 }
10200 }
10201 }
10202}
10203
10204#[derive(PartialEq, Debug)]
10206pub struct DataRouter;
10207
10208impl ::fidl_next::Discoverable for DataRouter {
10209 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
10210}
10211
10212#[cfg(target_os = "fuchsia")]
10213impl ::fidl_next::HasTransport for DataRouter {
10214 type Transport = ::fidl_next::fuchsia::zx::Channel;
10215}
10216
10217pub mod data_router {
10218 pub mod prelude {
10219 pub use crate::{
10220 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
10221 };
10222
10223 pub use crate::natural::DataRouterRouteResponse;
10224
10225 pub use crate::natural::RouteRequest;
10226
10227 pub use crate::natural::RouterError;
10228 }
10229
10230 pub struct Route;
10231
10232 impl ::fidl_next::Method for Route {
10233 const ORDINAL: u64 = 3352890635970754564;
10234 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10235 ::fidl_next::protocol::Flexibility::Flexible;
10236
10237 type Protocol = crate::DataRouter;
10238
10239 type Request = crate::wire::RouteRequest<'static>;
10240 }
10241
10242 impl ::fidl_next::TwoWayMethod for Route {
10243 type Response = ::fidl_next::WireFlexibleResult<
10244 'static,
10245 crate::wire::DataRouterRouteResponse<'static>,
10246 crate::wire::RouterError,
10247 >;
10248 }
10249
10250 impl<___R> ::fidl_next::Respond<___R> for Route {
10251 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10252
10253 fn respond(response: ___R) -> Self::Output {
10254 ::fidl_next::FlexibleResult::Ok(response)
10255 }
10256 }
10257
10258 impl<___R> ::fidl_next::RespondErr<___R> for Route {
10259 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10260
10261 fn respond_err(response: ___R) -> Self::Output {
10262 ::fidl_next::FlexibleResult::Err(response)
10263 }
10264 }
10265
10266 mod ___detail {
10267 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
10268 where
10269 ___T: ::fidl_next::Transport,
10270 {
10271 type Client = DataRouterClient<___T>;
10272 type Server = DataRouterServer<___T>;
10273 }
10274
10275 #[repr(transparent)]
10277 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
10278 #[allow(dead_code)]
10279 client: ::fidl_next::protocol::Client<___T>,
10280 }
10281
10282 impl<___T> DataRouterClient<___T>
10283 where
10284 ___T: ::fidl_next::Transport,
10285 {
10286 pub fn route_with<___R>(
10287 &self,
10288 request: ___R,
10289 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10290 where
10291 ___R: ::fidl_next::Encode<
10292 crate::wire::RouteRequest<'static>,
10293 <___T as ::fidl_next::Transport>::SendBuffer,
10294 >,
10295 {
10296 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10297 3352890635970754564,
10298 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
10299 request,
10300 ))
10301 }
10302 }
10303
10304 #[repr(transparent)]
10306 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
10307 server: ::fidl_next::protocol::Server<___T>,
10308 }
10309
10310 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
10311 }
10312}
10313
10314pub trait DataRouterClientHandler<
10318 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10319 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10320>
10321{
10322 fn on_unknown_interaction(
10323 &mut self,
10324 ordinal: u64,
10325 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10326 ::core::future::ready(())
10327 }
10328}
10329
10330impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
10331where
10332 ___T: ::fidl_next::Transport,
10333{
10334 async fn on_unknown_interaction(&mut self, _: u64) {}
10335}
10336
10337impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
10338where
10339 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
10340 ___T: ::fidl_next::Transport,
10341{
10342 async fn on_event(
10343 handler: &mut ___H,
10344 ordinal: u64,
10345 flexibility: ::fidl_next::protocol::Flexibility,
10346 buffer: ___T::RecvBuffer,
10347 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10348 match ordinal {
10349 ordinal => {
10350 handler.on_unknown_interaction(ordinal).await;
10351 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10352 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10353 } else {
10354 Ok(())
10355 }
10356 }
10357 }
10358 }
10359}
10360
10361pub trait DataRouterServerHandler<
10365 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10366 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10367>
10368{
10369 fn route(
10370 &mut self,
10371
10372 request: ::fidl_next::Request<data_router::Route, ___T>,
10373
10374 responder: ::fidl_next::Responder<data_router::Route, ___T>,
10375 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10376
10377 fn on_unknown_interaction(
10378 &mut self,
10379 ordinal: u64,
10380 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10381 ::core::future::ready(())
10382 }
10383}
10384
10385impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
10386where
10387 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
10388 ___T: ::fidl_next::Transport,
10389 <data_router::Route as ::fidl_next::Method>::Request:
10390 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10391{
10392 async fn on_one_way(
10393 handler: &mut ___H,
10394 ordinal: u64,
10395 flexibility: ::fidl_next::protocol::Flexibility,
10396 buffer: ___T::RecvBuffer,
10397 ) -> ::core::result::Result<
10398 (),
10399 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10400 > {
10401 match ordinal {
10402 ordinal => {
10403 handler.on_unknown_interaction(ordinal).await;
10404 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10405 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10406 } else {
10407 Ok(())
10408 }
10409 }
10410 }
10411 }
10412
10413 async fn on_two_way(
10414 handler: &mut ___H,
10415 ordinal: u64,
10416 flexibility: ::fidl_next::protocol::Flexibility,
10417 buffer: ___T::RecvBuffer,
10418 responder: ::fidl_next::protocol::Responder<___T>,
10419 ) -> ::core::result::Result<
10420 (),
10421 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10422 > {
10423 match ordinal {
10424 3352890635970754564 => {
10425 let responder = ::fidl_next::Responder::from_untyped(responder);
10426
10427 match ::fidl_next::DecoderExt::decode(buffer) {
10428 Ok(decoded) => {
10429 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
10430 Ok(())
10431 }
10432 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10433 ordinal: 3352890635970754564,
10434 error,
10435 }),
10436 }
10437 }
10438
10439 ordinal => {
10440 handler.on_unknown_interaction(ordinal).await;
10441 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10442 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10443 } else {
10444 responder
10445 .respond(
10446 ordinal,
10447 flexibility,
10448 ::fidl_next::Flexible::<()>::FrameworkErr(
10449 ::fidl_next::FrameworkError::UnknownMethod,
10450 ),
10451 )
10452 .expect("encoding a framework error should never fail")
10453 .await?;
10454 Ok(())
10455 }
10456 }
10457 }
10458 }
10459}
10460
10461#[derive(PartialEq, Debug)]
10463pub struct DictionaryDrainIterator;
10464
10465#[cfg(target_os = "fuchsia")]
10466impl ::fidl_next::HasTransport for DictionaryDrainIterator {
10467 type Transport = ::fidl_next::fuchsia::zx::Channel;
10468}
10469
10470pub mod dictionary_drain_iterator {
10471 pub mod prelude {
10472 pub use crate::{
10473 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
10474 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
10475 };
10476
10477 pub use crate::natural::CapabilityStoreError;
10478
10479 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
10480
10481 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
10482 }
10483
10484 pub struct GetNext;
10485
10486 impl ::fidl_next::Method for GetNext {
10487 const ORDINAL: u64 = 5728722530628427873;
10488 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10489 ::fidl_next::protocol::Flexibility::Flexible;
10490
10491 type Protocol = crate::DictionaryDrainIterator;
10492
10493 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
10494 }
10495
10496 impl ::fidl_next::TwoWayMethod for GetNext {
10497 type Response = ::fidl_next::WireFlexibleResult<
10498 'static,
10499 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
10500 crate::wire::CapabilityStoreError,
10501 >;
10502 }
10503
10504 impl<___R> ::fidl_next::Respond<___R> for GetNext {
10505 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10506
10507 fn respond(response: ___R) -> Self::Output {
10508 ::fidl_next::FlexibleResult::Ok(response)
10509 }
10510 }
10511
10512 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
10513 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10514
10515 fn respond_err(response: ___R) -> Self::Output {
10516 ::fidl_next::FlexibleResult::Err(response)
10517 }
10518 }
10519
10520 mod ___detail {
10521 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
10522 where
10523 ___T: ::fidl_next::Transport,
10524 {
10525 type Client = DictionaryDrainIteratorClient<___T>;
10526 type Server = DictionaryDrainIteratorServer<___T>;
10527 }
10528
10529 #[repr(transparent)]
10531 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
10532 #[allow(dead_code)]
10533 client: ::fidl_next::protocol::Client<___T>,
10534 }
10535
10536 impl<___T> DictionaryDrainIteratorClient<___T>
10537 where
10538 ___T: ::fidl_next::Transport,
10539 {
10540 #[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"]
10541 pub fn get_next(
10542 &self,
10543
10544 start_id: impl ::fidl_next::Encode<
10545 ::fidl_next::WireU64,
10546 <___T as ::fidl_next::Transport>::SendBuffer,
10547 >,
10548
10549 limit: impl ::fidl_next::Encode<
10550 ::fidl_next::WireU32,
10551 <___T as ::fidl_next::Transport>::SendBuffer,
10552 >,
10553 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10554 where
10555 <___T as ::fidl_next::Transport>::SendBuffer:
10556 ::fidl_next::encoder::InternalHandleEncoder,
10557 {
10558 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
10559 start_id,
10560
10561 limit,
10562 })
10563 }
10564
10565 #[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"]
10566 pub fn get_next_with<___R>(
10567 &self,
10568 request: ___R,
10569 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10570 where
10571 ___R: ::fidl_next::Encode<
10572 crate::wire::DictionaryDrainIteratorGetNextRequest,
10573 <___T as ::fidl_next::Transport>::SendBuffer,
10574 >,
10575 {
10576 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10577 5728722530628427873,
10578 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
10579 request,
10580 ))
10581 }
10582 }
10583
10584 #[repr(transparent)]
10586 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
10587 server: ::fidl_next::protocol::Server<___T>,
10588 }
10589
10590 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
10591 }
10592}
10593
10594pub trait DictionaryDrainIteratorClientHandler<
10598 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10599 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10600>
10601{
10602 fn on_unknown_interaction(
10603 &mut self,
10604 ordinal: u64,
10605 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10606 ::core::future::ready(())
10607 }
10608}
10609
10610impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
10611where
10612 ___T: ::fidl_next::Transport,
10613{
10614 async fn on_unknown_interaction(&mut self, _: u64) {}
10615}
10616
10617impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
10618where
10619 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
10620 ___T: ::fidl_next::Transport,
10621{
10622 async fn on_event(
10623 handler: &mut ___H,
10624 ordinal: u64,
10625 flexibility: ::fidl_next::protocol::Flexibility,
10626 buffer: ___T::RecvBuffer,
10627 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10628 match ordinal {
10629 ordinal => {
10630 handler.on_unknown_interaction(ordinal).await;
10631 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10632 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10633 } else {
10634 Ok(())
10635 }
10636 }
10637 }
10638 }
10639}
10640
10641pub trait DictionaryDrainIteratorServerHandler<
10645 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10646 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10647>
10648{
10649 #[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"]
10650 fn get_next(
10651 &mut self,
10652
10653 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
10654
10655 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
10656 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10657
10658 fn on_unknown_interaction(
10659 &mut self,
10660 ordinal: u64,
10661 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10662 ::core::future::ready(())
10663 }
10664}
10665
10666impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
10667where
10668 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
10669 ___T: ::fidl_next::Transport,
10670 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
10671 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10672{
10673 async fn on_one_way(
10674 handler: &mut ___H,
10675 ordinal: u64,
10676 flexibility: ::fidl_next::protocol::Flexibility,
10677 buffer: ___T::RecvBuffer,
10678 ) -> ::core::result::Result<
10679 (),
10680 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10681 > {
10682 match ordinal {
10683 ordinal => {
10684 handler.on_unknown_interaction(ordinal).await;
10685 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10686 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10687 } else {
10688 Ok(())
10689 }
10690 }
10691 }
10692 }
10693
10694 async fn on_two_way(
10695 handler: &mut ___H,
10696 ordinal: u64,
10697 flexibility: ::fidl_next::protocol::Flexibility,
10698 buffer: ___T::RecvBuffer,
10699 responder: ::fidl_next::protocol::Responder<___T>,
10700 ) -> ::core::result::Result<
10701 (),
10702 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10703 > {
10704 match ordinal {
10705 5728722530628427873 => {
10706 let responder = ::fidl_next::Responder::from_untyped(responder);
10707
10708 match ::fidl_next::DecoderExt::decode(buffer) {
10709 Ok(decoded) => {
10710 handler
10711 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
10712 .await;
10713 Ok(())
10714 }
10715 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10716 ordinal: 5728722530628427873,
10717 error,
10718 }),
10719 }
10720 }
10721
10722 ordinal => {
10723 handler.on_unknown_interaction(ordinal).await;
10724 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10725 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10726 } else {
10727 responder
10728 .respond(
10729 ordinal,
10730 flexibility,
10731 ::fidl_next::Flexible::<()>::FrameworkErr(
10732 ::fidl_next::FrameworkError::UnknownMethod,
10733 ),
10734 )
10735 .expect("encoding a framework error should never fail")
10736 .await?;
10737 Ok(())
10738 }
10739 }
10740 }
10741 }
10742}
10743
10744#[derive(PartialEq, Debug)]
10746pub struct DictionaryEnumerateIterator;
10747
10748#[cfg(target_os = "fuchsia")]
10749impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
10750 type Transport = ::fidl_next::fuchsia::zx::Channel;
10751}
10752
10753pub mod dictionary_enumerate_iterator {
10754 pub mod prelude {
10755 pub use crate::{
10756 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
10757 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
10758 };
10759
10760 pub use crate::natural::CapabilityStoreError;
10761
10762 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
10763
10764 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
10765 }
10766
10767 pub struct GetNext;
10768
10769 impl ::fidl_next::Method for GetNext {
10770 const ORDINAL: u64 = 1511164556663256527;
10771 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10772 ::fidl_next::protocol::Flexibility::Flexible;
10773
10774 type Protocol = crate::DictionaryEnumerateIterator;
10775
10776 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
10777 }
10778
10779 impl ::fidl_next::TwoWayMethod for GetNext {
10780 type Response = ::fidl_next::WireFlexibleResult<
10781 'static,
10782 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
10783 crate::wire::CapabilityStoreError,
10784 >;
10785 }
10786
10787 impl<___R> ::fidl_next::Respond<___R> for GetNext {
10788 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10789
10790 fn respond(response: ___R) -> Self::Output {
10791 ::fidl_next::FlexibleResult::Ok(response)
10792 }
10793 }
10794
10795 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
10796 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10797
10798 fn respond_err(response: ___R) -> Self::Output {
10799 ::fidl_next::FlexibleResult::Err(response)
10800 }
10801 }
10802
10803 mod ___detail {
10804 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
10805 where
10806 ___T: ::fidl_next::Transport,
10807 {
10808 type Client = DictionaryEnumerateIteratorClient<___T>;
10809 type Server = DictionaryEnumerateIteratorServer<___T>;
10810 }
10811
10812 #[repr(transparent)]
10814 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
10815 #[allow(dead_code)]
10816 client: ::fidl_next::protocol::Client<___T>,
10817 }
10818
10819 impl<___T> DictionaryEnumerateIteratorClient<___T>
10820 where
10821 ___T: ::fidl_next::Transport,
10822 {
10823 #[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"]
10824 pub fn get_next(
10825 &self,
10826
10827 start_id: impl ::fidl_next::Encode<
10828 ::fidl_next::WireU64,
10829 <___T as ::fidl_next::Transport>::SendBuffer,
10830 >,
10831
10832 limit: impl ::fidl_next::Encode<
10833 ::fidl_next::WireU32,
10834 <___T as ::fidl_next::Transport>::SendBuffer,
10835 >,
10836 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10837 where
10838 <___T as ::fidl_next::Transport>::SendBuffer:
10839 ::fidl_next::encoder::InternalHandleEncoder,
10840 {
10841 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
10842 start_id,
10843
10844 limit,
10845 })
10846 }
10847
10848 #[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"]
10849 pub fn get_next_with<___R>(
10850 &self,
10851 request: ___R,
10852 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10853 where
10854 ___R: ::fidl_next::Encode<
10855 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
10856 <___T as ::fidl_next::Transport>::SendBuffer,
10857 >,
10858 {
10859 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10860 1511164556663256527,
10861 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
10862 request,
10863 ))
10864 }
10865 }
10866
10867 #[repr(transparent)]
10869 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
10870 server: ::fidl_next::protocol::Server<___T>,
10871 }
10872
10873 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
10874 }
10875}
10876
10877pub trait DictionaryEnumerateIteratorClientHandler<
10881 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10882 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10883>
10884{
10885 fn on_unknown_interaction(
10886 &mut self,
10887 ordinal: u64,
10888 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10889 ::core::future::ready(())
10890 }
10891}
10892
10893impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
10894where
10895 ___T: ::fidl_next::Transport,
10896{
10897 async fn on_unknown_interaction(&mut self, _: u64) {}
10898}
10899
10900impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
10901where
10902 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
10903 ___T: ::fidl_next::Transport,
10904{
10905 async fn on_event(
10906 handler: &mut ___H,
10907 ordinal: u64,
10908 flexibility: ::fidl_next::protocol::Flexibility,
10909 buffer: ___T::RecvBuffer,
10910 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10911 match ordinal {
10912 ordinal => {
10913 handler.on_unknown_interaction(ordinal).await;
10914 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10915 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10916 } else {
10917 Ok(())
10918 }
10919 }
10920 }
10921 }
10922}
10923
10924pub trait DictionaryEnumerateIteratorServerHandler<
10928 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10929 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10930>
10931{
10932 #[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"]
10933 fn get_next(
10934 &mut self,
10935
10936 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
10937
10938 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
10939 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10940
10941 fn on_unknown_interaction(
10942 &mut self,
10943 ordinal: u64,
10944 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10945 ::core::future::ready(())
10946 }
10947}
10948
10949impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
10950where
10951 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
10952 ___T: ::fidl_next::Transport,
10953 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
10954 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10955{
10956 async fn on_one_way(
10957 handler: &mut ___H,
10958 ordinal: u64,
10959 flexibility: ::fidl_next::protocol::Flexibility,
10960 buffer: ___T::RecvBuffer,
10961 ) -> ::core::result::Result<
10962 (),
10963 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10964 > {
10965 match ordinal {
10966 ordinal => {
10967 handler.on_unknown_interaction(ordinal).await;
10968 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10969 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10970 } else {
10971 Ok(())
10972 }
10973 }
10974 }
10975 }
10976
10977 async fn on_two_way(
10978 handler: &mut ___H,
10979 ordinal: u64,
10980 flexibility: ::fidl_next::protocol::Flexibility,
10981 buffer: ___T::RecvBuffer,
10982 responder: ::fidl_next::protocol::Responder<___T>,
10983 ) -> ::core::result::Result<
10984 (),
10985 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10986 > {
10987 match ordinal {
10988 1511164556663256527 => {
10989 let responder = ::fidl_next::Responder::from_untyped(responder);
10990
10991 match ::fidl_next::DecoderExt::decode(buffer) {
10992 Ok(decoded) => {
10993 handler
10994 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
10995 .await;
10996 Ok(())
10997 }
10998 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10999 ordinal: 1511164556663256527,
11000 error,
11001 }),
11002 }
11003 }
11004
11005 ordinal => {
11006 handler.on_unknown_interaction(ordinal).await;
11007 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11008 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11009 } else {
11010 responder
11011 .respond(
11012 ordinal,
11013 flexibility,
11014 ::fidl_next::Flexible::<()>::FrameworkErr(
11015 ::fidl_next::FrameworkError::UnknownMethod,
11016 ),
11017 )
11018 .expect("encoding a framework error should never fail")
11019 .await?;
11020 Ok(())
11021 }
11022 }
11023 }
11024 }
11025}
11026
11027#[derive(PartialEq, Debug)]
11029pub struct DictionaryKeysIterator;
11030
11031#[cfg(target_os = "fuchsia")]
11032impl ::fidl_next::HasTransport for DictionaryKeysIterator {
11033 type Transport = ::fidl_next::fuchsia::zx::Channel;
11034}
11035
11036pub mod dictionary_keys_iterator {
11037 pub mod prelude {
11038 pub use crate::{
11039 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
11040 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
11041 };
11042
11043 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
11044 }
11045
11046 pub struct GetNext;
11047
11048 impl ::fidl_next::Method for GetNext {
11049 const ORDINAL: u64 = 4987781442555247955;
11050 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11051 ::fidl_next::protocol::Flexibility::Flexible;
11052
11053 type Protocol = crate::DictionaryKeysIterator;
11054
11055 type Request = ();
11056 }
11057
11058 impl ::fidl_next::TwoWayMethod for GetNext {
11059 type Response = ::fidl_next::WireFlexible<
11060 'static,
11061 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
11062 >;
11063 }
11064
11065 impl<___R> ::fidl_next::Respond<___R> for GetNext {
11066 type Output =
11067 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
11068
11069 fn respond(response: ___R) -> Self::Output {
11070 ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
11071 keys: response,
11072 })
11073 }
11074 }
11075
11076 mod ___detail {
11077 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
11078 where
11079 ___T: ::fidl_next::Transport,
11080 {
11081 type Client = DictionaryKeysIteratorClient<___T>;
11082 type Server = DictionaryKeysIteratorServer<___T>;
11083 }
11084
11085 #[repr(transparent)]
11087 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
11088 #[allow(dead_code)]
11089 client: ::fidl_next::protocol::Client<___T>,
11090 }
11091
11092 impl<___T> DictionaryKeysIteratorClient<___T>
11093 where
11094 ___T: ::fidl_next::Transport,
11095 {
11096 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
11097 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11098 4987781442555247955,
11099 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
11100 (),
11101 ))
11102 }
11103 }
11104
11105 #[repr(transparent)]
11107 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
11108 server: ::fidl_next::protocol::Server<___T>,
11109 }
11110
11111 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11112 }
11113}
11114
11115pub trait DictionaryKeysIteratorClientHandler<
11119 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11120 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11121>
11122{
11123 fn on_unknown_interaction(
11124 &mut self,
11125 ordinal: u64,
11126 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11127 ::core::future::ready(())
11128 }
11129}
11130
11131impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11132where
11133 ___T: ::fidl_next::Transport,
11134{
11135 async fn on_unknown_interaction(&mut self, _: u64) {}
11136}
11137
11138impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
11139where
11140 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
11141 ___T: ::fidl_next::Transport,
11142{
11143 async fn on_event(
11144 handler: &mut ___H,
11145 ordinal: u64,
11146 flexibility: ::fidl_next::protocol::Flexibility,
11147 buffer: ___T::RecvBuffer,
11148 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11149 match ordinal {
11150 ordinal => {
11151 handler.on_unknown_interaction(ordinal).await;
11152 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11153 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11154 } else {
11155 Ok(())
11156 }
11157 }
11158 }
11159 }
11160}
11161
11162pub trait DictionaryKeysIteratorServerHandler<
11166 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11167 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11168>
11169{
11170 fn get_next(
11171 &mut self,
11172
11173 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
11174 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11175
11176 fn on_unknown_interaction(
11177 &mut self,
11178 ordinal: u64,
11179 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11180 ::core::future::ready(())
11181 }
11182}
11183
11184impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
11185where
11186 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
11187 ___T: ::fidl_next::Transport,
11188{
11189 async fn on_one_way(
11190 handler: &mut ___H,
11191 ordinal: u64,
11192 flexibility: ::fidl_next::protocol::Flexibility,
11193 buffer: ___T::RecvBuffer,
11194 ) -> ::core::result::Result<
11195 (),
11196 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11197 > {
11198 match ordinal {
11199 ordinal => {
11200 handler.on_unknown_interaction(ordinal).await;
11201 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11202 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11203 } else {
11204 Ok(())
11205 }
11206 }
11207 }
11208 }
11209
11210 async fn on_two_way(
11211 handler: &mut ___H,
11212 ordinal: u64,
11213 flexibility: ::fidl_next::protocol::Flexibility,
11214 buffer: ___T::RecvBuffer,
11215 responder: ::fidl_next::protocol::Responder<___T>,
11216 ) -> ::core::result::Result<
11217 (),
11218 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11219 > {
11220 match ordinal {
11221 4987781442555247955 => {
11222 let responder = ::fidl_next::Responder::from_untyped(responder);
11223
11224 handler.get_next(responder).await;
11225 Ok(())
11226 }
11227
11228 ordinal => {
11229 handler.on_unknown_interaction(ordinal).await;
11230 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11231 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11232 } else {
11233 responder
11234 .respond(
11235 ordinal,
11236 flexibility,
11237 ::fidl_next::Flexible::<()>::FrameworkErr(
11238 ::fidl_next::FrameworkError::UnknownMethod,
11239 ),
11240 )
11241 .expect("encoding a framework error should never fail")
11242 .await?;
11243 Ok(())
11244 }
11245 }
11246 }
11247 }
11248}
11249
11250#[derive(PartialEq, Debug)]
11252pub struct DictionaryRouter;
11253
11254impl ::fidl_next::Discoverable for DictionaryRouter {
11255 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
11256}
11257
11258#[cfg(target_os = "fuchsia")]
11259impl ::fidl_next::HasTransport for DictionaryRouter {
11260 type Transport = ::fidl_next::fuchsia::zx::Channel;
11261}
11262
11263pub mod dictionary_router {
11264 pub mod prelude {
11265 pub use crate::{
11266 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
11267 dictionary_router,
11268 };
11269
11270 pub use crate::natural::DictionaryRouterRouteResponse;
11271
11272 pub use crate::natural::RouteRequest;
11273
11274 pub use crate::natural::RouterError;
11275 }
11276
11277 pub struct Route;
11278
11279 impl ::fidl_next::Method for Route {
11280 const ORDINAL: u64 = 8164012099375978399;
11281 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11282 ::fidl_next::protocol::Flexibility::Flexible;
11283
11284 type Protocol = crate::DictionaryRouter;
11285
11286 type Request = crate::wire::RouteRequest<'static>;
11287 }
11288
11289 impl ::fidl_next::TwoWayMethod for Route {
11290 type Response = ::fidl_next::WireFlexibleResult<
11291 'static,
11292 crate::wire::DictionaryRouterRouteResponse,
11293 crate::wire::RouterError,
11294 >;
11295 }
11296
11297 impl<___R> ::fidl_next::Respond<___R> for Route {
11298 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11299
11300 fn respond(response: ___R) -> Self::Output {
11301 ::fidl_next::FlexibleResult::Ok(response)
11302 }
11303 }
11304
11305 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11306 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11307
11308 fn respond_err(response: ___R) -> Self::Output {
11309 ::fidl_next::FlexibleResult::Err(response)
11310 }
11311 }
11312
11313 mod ___detail {
11314 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
11315 where
11316 ___T: ::fidl_next::Transport,
11317 {
11318 type Client = DictionaryRouterClient<___T>;
11319 type Server = DictionaryRouterServer<___T>;
11320 }
11321
11322 #[repr(transparent)]
11324 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
11325 #[allow(dead_code)]
11326 client: ::fidl_next::protocol::Client<___T>,
11327 }
11328
11329 impl<___T> DictionaryRouterClient<___T>
11330 where
11331 ___T: ::fidl_next::Transport,
11332 {
11333 pub fn route_with<___R>(
11334 &self,
11335 request: ___R,
11336 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11337 where
11338 ___R: ::fidl_next::Encode<
11339 crate::wire::RouteRequest<'static>,
11340 <___T as ::fidl_next::Transport>::SendBuffer,
11341 >,
11342 {
11343 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11344 8164012099375978399,
11345 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11346 request,
11347 ))
11348 }
11349 }
11350
11351 #[repr(transparent)]
11353 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
11354 server: ::fidl_next::protocol::Server<___T>,
11355 }
11356
11357 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
11358 }
11359}
11360
11361pub trait DictionaryRouterClientHandler<
11365 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11366 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11367>
11368{
11369 fn on_unknown_interaction(
11370 &mut self,
11371 ordinal: u64,
11372 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11373 ::core::future::ready(())
11374 }
11375}
11376
11377impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11378where
11379 ___T: ::fidl_next::Transport,
11380{
11381 async fn on_unknown_interaction(&mut self, _: u64) {}
11382}
11383
11384impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
11385where
11386 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
11387 ___T: ::fidl_next::Transport,
11388{
11389 async fn on_event(
11390 handler: &mut ___H,
11391 ordinal: u64,
11392 flexibility: ::fidl_next::protocol::Flexibility,
11393 buffer: ___T::RecvBuffer,
11394 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11395 match ordinal {
11396 ordinal => {
11397 handler.on_unknown_interaction(ordinal).await;
11398 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11399 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11400 } else {
11401 Ok(())
11402 }
11403 }
11404 }
11405 }
11406}
11407
11408pub trait DictionaryRouterServerHandler<
11412 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11413 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11414>
11415{
11416 fn route(
11417 &mut self,
11418
11419 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
11420
11421 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
11422 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11423
11424 fn on_unknown_interaction(
11425 &mut self,
11426 ordinal: u64,
11427 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11428 ::core::future::ready(())
11429 }
11430}
11431
11432impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
11433where
11434 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
11435 ___T: ::fidl_next::Transport,
11436 <dictionary_router::Route as ::fidl_next::Method>::Request:
11437 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11438{
11439 async fn on_one_way(
11440 handler: &mut ___H,
11441 ordinal: u64,
11442 flexibility: ::fidl_next::protocol::Flexibility,
11443 buffer: ___T::RecvBuffer,
11444 ) -> ::core::result::Result<
11445 (),
11446 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11447 > {
11448 match ordinal {
11449 ordinal => {
11450 handler.on_unknown_interaction(ordinal).await;
11451 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11452 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11453 } else {
11454 Ok(())
11455 }
11456 }
11457 }
11458 }
11459
11460 async fn on_two_way(
11461 handler: &mut ___H,
11462 ordinal: u64,
11463 flexibility: ::fidl_next::protocol::Flexibility,
11464 buffer: ___T::RecvBuffer,
11465 responder: ::fidl_next::protocol::Responder<___T>,
11466 ) -> ::core::result::Result<
11467 (),
11468 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11469 > {
11470 match ordinal {
11471 8164012099375978399 => {
11472 let responder = ::fidl_next::Responder::from_untyped(responder);
11473
11474 match ::fidl_next::DecoderExt::decode(buffer) {
11475 Ok(decoded) => {
11476 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11477 Ok(())
11478 }
11479 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11480 ordinal: 8164012099375978399,
11481 error,
11482 }),
11483 }
11484 }
11485
11486 ordinal => {
11487 handler.on_unknown_interaction(ordinal).await;
11488 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11489 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11490 } else {
11491 responder
11492 .respond(
11493 ordinal,
11494 flexibility,
11495 ::fidl_next::Flexible::<()>::FrameworkErr(
11496 ::fidl_next::FrameworkError::UnknownMethod,
11497 ),
11498 )
11499 .expect("encoding a framework error should never fail")
11500 .await?;
11501 Ok(())
11502 }
11503 }
11504 }
11505 }
11506}
11507
11508#[derive(PartialEq, Debug)]
11510pub struct DirConnectorRouter;
11511
11512impl ::fidl_next::Discoverable for DirConnectorRouter {
11513 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
11514}
11515
11516#[cfg(target_os = "fuchsia")]
11517impl ::fidl_next::HasTransport for DirConnectorRouter {
11518 type Transport = ::fidl_next::fuchsia::zx::Channel;
11519}
11520
11521pub mod dir_connector_router {
11522 pub mod prelude {
11523 pub use crate::{
11524 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
11525 dir_connector_router,
11526 };
11527
11528 pub use crate::natural::DirConnectorRouterRouteResponse;
11529
11530 pub use crate::natural::RouteRequest;
11531
11532 pub use crate::natural::RouterError;
11533 }
11534
11535 pub struct Route;
11536
11537 impl ::fidl_next::Method for Route {
11538 const ORDINAL: u64 = 972231070188342848;
11539 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11540 ::fidl_next::protocol::Flexibility::Flexible;
11541
11542 type Protocol = crate::DirConnectorRouter;
11543
11544 type Request = crate::wire::RouteRequest<'static>;
11545 }
11546
11547 impl ::fidl_next::TwoWayMethod for Route {
11548 type Response = ::fidl_next::WireFlexibleResult<
11549 'static,
11550 crate::wire::DirConnectorRouterRouteResponse,
11551 crate::wire::RouterError,
11552 >;
11553 }
11554
11555 impl<___R> ::fidl_next::Respond<___R> for Route {
11556 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11557
11558 fn respond(response: ___R) -> Self::Output {
11559 ::fidl_next::FlexibleResult::Ok(response)
11560 }
11561 }
11562
11563 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11564 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11565
11566 fn respond_err(response: ___R) -> Self::Output {
11567 ::fidl_next::FlexibleResult::Err(response)
11568 }
11569 }
11570
11571 mod ___detail {
11572 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
11573 where
11574 ___T: ::fidl_next::Transport,
11575 {
11576 type Client = DirConnectorRouterClient<___T>;
11577 type Server = DirConnectorRouterServer<___T>;
11578 }
11579
11580 #[repr(transparent)]
11582 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
11583 #[allow(dead_code)]
11584 client: ::fidl_next::protocol::Client<___T>,
11585 }
11586
11587 impl<___T> DirConnectorRouterClient<___T>
11588 where
11589 ___T: ::fidl_next::Transport,
11590 {
11591 pub fn route_with<___R>(
11592 &self,
11593 request: ___R,
11594 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11595 where
11596 ___R: ::fidl_next::Encode<
11597 crate::wire::RouteRequest<'static>,
11598 <___T as ::fidl_next::Transport>::SendBuffer,
11599 >,
11600 {
11601 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11602 972231070188342848,
11603 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11604 request,
11605 ))
11606 }
11607 }
11608
11609 #[repr(transparent)]
11611 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
11612 server: ::fidl_next::protocol::Server<___T>,
11613 }
11614
11615 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
11616 }
11617}
11618
11619pub trait DirConnectorRouterClientHandler<
11623 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11624 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11625>
11626{
11627 fn on_unknown_interaction(
11628 &mut self,
11629 ordinal: u64,
11630 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11631 ::core::future::ready(())
11632 }
11633}
11634
11635impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11636where
11637 ___T: ::fidl_next::Transport,
11638{
11639 async fn on_unknown_interaction(&mut self, _: u64) {}
11640}
11641
11642impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
11643where
11644 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
11645 ___T: ::fidl_next::Transport,
11646{
11647 async fn on_event(
11648 handler: &mut ___H,
11649 ordinal: u64,
11650 flexibility: ::fidl_next::protocol::Flexibility,
11651 buffer: ___T::RecvBuffer,
11652 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11653 match ordinal {
11654 ordinal => {
11655 handler.on_unknown_interaction(ordinal).await;
11656 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11657 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11658 } else {
11659 Ok(())
11660 }
11661 }
11662 }
11663 }
11664}
11665
11666pub trait DirConnectorRouterServerHandler<
11670 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11671 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11672>
11673{
11674 fn route(
11675 &mut self,
11676
11677 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
11678
11679 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
11680 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11681
11682 fn on_unknown_interaction(
11683 &mut self,
11684 ordinal: u64,
11685 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11686 ::core::future::ready(())
11687 }
11688}
11689
11690impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
11691where
11692 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
11693 ___T: ::fidl_next::Transport,
11694 <dir_connector_router::Route as ::fidl_next::Method>::Request:
11695 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11696{
11697 async fn on_one_way(
11698 handler: &mut ___H,
11699 ordinal: u64,
11700 flexibility: ::fidl_next::protocol::Flexibility,
11701 buffer: ___T::RecvBuffer,
11702 ) -> ::core::result::Result<
11703 (),
11704 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11705 > {
11706 match ordinal {
11707 ordinal => {
11708 handler.on_unknown_interaction(ordinal).await;
11709 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11710 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11711 } else {
11712 Ok(())
11713 }
11714 }
11715 }
11716 }
11717
11718 async fn on_two_way(
11719 handler: &mut ___H,
11720 ordinal: u64,
11721 flexibility: ::fidl_next::protocol::Flexibility,
11722 buffer: ___T::RecvBuffer,
11723 responder: ::fidl_next::protocol::Responder<___T>,
11724 ) -> ::core::result::Result<
11725 (),
11726 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11727 > {
11728 match ordinal {
11729 972231070188342848 => {
11730 let responder = ::fidl_next::Responder::from_untyped(responder);
11731
11732 match ::fidl_next::DecoderExt::decode(buffer) {
11733 Ok(decoded) => {
11734 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11735 Ok(())
11736 }
11737 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11738 ordinal: 972231070188342848,
11739 error,
11740 }),
11741 }
11742 }
11743
11744 ordinal => {
11745 handler.on_unknown_interaction(ordinal).await;
11746 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11747 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11748 } else {
11749 responder
11750 .respond(
11751 ordinal,
11752 flexibility,
11753 ::fidl_next::Flexible::<()>::FrameworkErr(
11754 ::fidl_next::FrameworkError::UnknownMethod,
11755 ),
11756 )
11757 .expect("encoding a framework error should never fail")
11758 .await?;
11759 Ok(())
11760 }
11761 }
11762 }
11763 }
11764}
11765
11766#[derive(PartialEq, Debug)]
11768pub struct DirEntryRouter;
11769
11770impl ::fidl_next::Discoverable for DirEntryRouter {
11771 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
11772}
11773
11774#[cfg(target_os = "fuchsia")]
11775impl ::fidl_next::HasTransport for DirEntryRouter {
11776 type Transport = ::fidl_next::fuchsia::zx::Channel;
11777}
11778
11779pub mod dir_entry_router {
11780 pub mod prelude {
11781 pub use crate::{
11782 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
11783 dir_entry_router,
11784 };
11785
11786 pub use crate::natural::DirEntryRouterRouteResponse;
11787
11788 pub use crate::natural::RouteRequest;
11789
11790 pub use crate::natural::RouterError;
11791 }
11792
11793 pub struct Route;
11794
11795 impl ::fidl_next::Method for Route {
11796 const ORDINAL: u64 = 1929392218567642066;
11797 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11798 ::fidl_next::protocol::Flexibility::Flexible;
11799
11800 type Protocol = crate::DirEntryRouter;
11801
11802 type Request = crate::wire::RouteRequest<'static>;
11803 }
11804
11805 impl ::fidl_next::TwoWayMethod for Route {
11806 type Response = ::fidl_next::WireFlexibleResult<
11807 'static,
11808 crate::wire::DirEntryRouterRouteResponse,
11809 crate::wire::RouterError,
11810 >;
11811 }
11812
11813 impl<___R> ::fidl_next::Respond<___R> for Route {
11814 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11815
11816 fn respond(response: ___R) -> Self::Output {
11817 ::fidl_next::FlexibleResult::Ok(response)
11818 }
11819 }
11820
11821 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11822 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11823
11824 fn respond_err(response: ___R) -> Self::Output {
11825 ::fidl_next::FlexibleResult::Err(response)
11826 }
11827 }
11828
11829 mod ___detail {
11830 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
11831 where
11832 ___T: ::fidl_next::Transport,
11833 {
11834 type Client = DirEntryRouterClient<___T>;
11835 type Server = DirEntryRouterServer<___T>;
11836 }
11837
11838 #[repr(transparent)]
11840 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
11841 #[allow(dead_code)]
11842 client: ::fidl_next::protocol::Client<___T>,
11843 }
11844
11845 impl<___T> DirEntryRouterClient<___T>
11846 where
11847 ___T: ::fidl_next::Transport,
11848 {
11849 pub fn route_with<___R>(
11850 &self,
11851 request: ___R,
11852 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11853 where
11854 ___R: ::fidl_next::Encode<
11855 crate::wire::RouteRequest<'static>,
11856 <___T as ::fidl_next::Transport>::SendBuffer,
11857 >,
11858 {
11859 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11860 1929392218567642066,
11861 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11862 request,
11863 ))
11864 }
11865 }
11866
11867 #[repr(transparent)]
11869 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
11870 server: ::fidl_next::protocol::Server<___T>,
11871 }
11872
11873 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
11874 }
11875}
11876
11877pub trait DirEntryRouterClientHandler<
11881 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11882 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11883>
11884{
11885 fn on_unknown_interaction(
11886 &mut self,
11887 ordinal: u64,
11888 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11889 ::core::future::ready(())
11890 }
11891}
11892
11893impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11894where
11895 ___T: ::fidl_next::Transport,
11896{
11897 async fn on_unknown_interaction(&mut self, _: u64) {}
11898}
11899
11900impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
11901where
11902 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
11903 ___T: ::fidl_next::Transport,
11904{
11905 async fn on_event(
11906 handler: &mut ___H,
11907 ordinal: u64,
11908 flexibility: ::fidl_next::protocol::Flexibility,
11909 buffer: ___T::RecvBuffer,
11910 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11911 match ordinal {
11912 ordinal => {
11913 handler.on_unknown_interaction(ordinal).await;
11914 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11915 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11916 } else {
11917 Ok(())
11918 }
11919 }
11920 }
11921 }
11922}
11923
11924pub trait DirEntryRouterServerHandler<
11928 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11929 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11930>
11931{
11932 fn route(
11933 &mut self,
11934
11935 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
11936
11937 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
11938 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11939
11940 fn on_unknown_interaction(
11941 &mut self,
11942 ordinal: u64,
11943 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11944 ::core::future::ready(())
11945 }
11946}
11947
11948impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
11949where
11950 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
11951 ___T: ::fidl_next::Transport,
11952 <dir_entry_router::Route as ::fidl_next::Method>::Request:
11953 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11954{
11955 async fn on_one_way(
11956 handler: &mut ___H,
11957 ordinal: u64,
11958 flexibility: ::fidl_next::protocol::Flexibility,
11959 buffer: ___T::RecvBuffer,
11960 ) -> ::core::result::Result<
11961 (),
11962 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11963 > {
11964 match ordinal {
11965 ordinal => {
11966 handler.on_unknown_interaction(ordinal).await;
11967 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11968 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11969 } else {
11970 Ok(())
11971 }
11972 }
11973 }
11974 }
11975
11976 async fn on_two_way(
11977 handler: &mut ___H,
11978 ordinal: u64,
11979 flexibility: ::fidl_next::protocol::Flexibility,
11980 buffer: ___T::RecvBuffer,
11981 responder: ::fidl_next::protocol::Responder<___T>,
11982 ) -> ::core::result::Result<
11983 (),
11984 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11985 > {
11986 match ordinal {
11987 1929392218567642066 => {
11988 let responder = ::fidl_next::Responder::from_untyped(responder);
11989
11990 match ::fidl_next::DecoderExt::decode(buffer) {
11991 Ok(decoded) => {
11992 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11993 Ok(())
11994 }
11995 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11996 ordinal: 1929392218567642066,
11997 error,
11998 }),
11999 }
12000 }
12001
12002 ordinal => {
12003 handler.on_unknown_interaction(ordinal).await;
12004 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12005 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12006 } else {
12007 responder
12008 .respond(
12009 ordinal,
12010 flexibility,
12011 ::fidl_next::Flexible::<()>::FrameworkErr(
12012 ::fidl_next::FrameworkError::UnknownMethod,
12013 ),
12014 )
12015 .expect("encoding a framework error should never fail")
12016 .await?;
12017 Ok(())
12018 }
12019 }
12020 }
12021 }
12022}
12023
12024#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
12026#[derive(PartialEq, Debug)]
12027pub struct DirReceiver;
12028
12029impl ::fidl_next::Discoverable for DirReceiver {
12030 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
12031}
12032
12033#[cfg(target_os = "fuchsia")]
12034impl ::fidl_next::HasTransport for DirReceiver {
12035 type Transport = ::fidl_next::fuchsia::zx::Channel;
12036}
12037
12038pub mod dir_receiver {
12039 pub mod prelude {
12040 pub use crate::{
12041 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
12042 };
12043
12044 pub use crate::natural::DirReceiverReceiveRequest;
12045 }
12046
12047 pub struct Receive;
12048
12049 impl ::fidl_next::Method for Receive {
12050 const ORDINAL: u64 = 926684461087488948;
12051 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12052 ::fidl_next::protocol::Flexibility::Flexible;
12053
12054 type Protocol = crate::DirReceiver;
12055
12056 type Request = crate::wire::DirReceiverReceiveRequest<'static>;
12057 }
12058
12059 mod ___detail {
12060 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
12061 where
12062 ___T: ::fidl_next::Transport,
12063 {
12064 type Client = DirReceiverClient<___T>;
12065 type Server = DirReceiverServer<___T>;
12066 }
12067
12068 #[repr(transparent)]
12070 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
12071 #[allow(dead_code)]
12072 client: ::fidl_next::protocol::Client<___T>,
12073 }
12074
12075 impl<___T> DirReceiverClient<___T>
12076 where
12077 ___T: ::fidl_next::Transport,
12078 {
12079 #[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.\n"]
12080 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
12081 where
12082 ___R: ::fidl_next::Encode<
12083 crate::wire::DirReceiverReceiveRequest<'static>,
12084 <___T as ::fidl_next::Transport>::SendBuffer,
12085 >,
12086 {
12087 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
12088 926684461087488948,
12089 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
12090 request,
12091 ))
12092 }
12093 }
12094
12095 #[repr(transparent)]
12097 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
12098 server: ::fidl_next::protocol::Server<___T>,
12099 }
12100
12101 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
12102 }
12103}
12104
12105pub trait DirReceiverClientHandler<
12109 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12110 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12111>
12112{
12113 fn on_unknown_interaction(
12114 &mut self,
12115 ordinal: u64,
12116 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12117 ::core::future::ready(())
12118 }
12119}
12120
12121impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
12122where
12123 ___T: ::fidl_next::Transport,
12124{
12125 async fn on_unknown_interaction(&mut self, _: u64) {}
12126}
12127
12128impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
12129where
12130 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
12131 ___T: ::fidl_next::Transport,
12132{
12133 async fn on_event(
12134 handler: &mut ___H,
12135 ordinal: u64,
12136 flexibility: ::fidl_next::protocol::Flexibility,
12137 buffer: ___T::RecvBuffer,
12138 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12139 match ordinal {
12140 ordinal => {
12141 handler.on_unknown_interaction(ordinal).await;
12142 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12143 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12144 } else {
12145 Ok(())
12146 }
12147 }
12148 }
12149 }
12150}
12151
12152pub trait DirReceiverServerHandler<
12156 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12157 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12158>
12159{
12160 #[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.\n"]
12161 fn receive(
12162 &mut self,
12163
12164 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
12165 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12166
12167 fn on_unknown_interaction(
12168 &mut self,
12169 ordinal: u64,
12170 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12171 ::core::future::ready(())
12172 }
12173}
12174
12175impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
12176where
12177 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
12178 ___T: ::fidl_next::Transport,
12179 <dir_receiver::Receive as ::fidl_next::Method>::Request:
12180 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12181{
12182 async fn on_one_way(
12183 handler: &mut ___H,
12184 ordinal: u64,
12185 flexibility: ::fidl_next::protocol::Flexibility,
12186 buffer: ___T::RecvBuffer,
12187 ) -> ::core::result::Result<
12188 (),
12189 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12190 > {
12191 match ordinal {
12192 926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
12193 Ok(decoded) => {
12194 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
12195 Ok(())
12196 }
12197 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12198 ordinal: 926684461087488948,
12199 error,
12200 }),
12201 },
12202
12203 ordinal => {
12204 handler.on_unknown_interaction(ordinal).await;
12205 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12206 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12207 } else {
12208 Ok(())
12209 }
12210 }
12211 }
12212 }
12213
12214 async fn on_two_way(
12215 handler: &mut ___H,
12216 ordinal: u64,
12217 flexibility: ::fidl_next::protocol::Flexibility,
12218 buffer: ___T::RecvBuffer,
12219 responder: ::fidl_next::protocol::Responder<___T>,
12220 ) -> ::core::result::Result<
12221 (),
12222 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12223 > {
12224 match ordinal {
12225 ordinal => {
12226 handler.on_unknown_interaction(ordinal).await;
12227 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12228 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12229 } else {
12230 responder
12231 .respond(
12232 ordinal,
12233 flexibility,
12234 ::fidl_next::Flexible::<()>::FrameworkErr(
12235 ::fidl_next::FrameworkError::UnknownMethod,
12236 ),
12237 )
12238 .expect("encoding a framework error should never fail")
12239 .await?;
12240 Ok(())
12241 }
12242 }
12243 }
12244 }
12245}
12246
12247#[derive(PartialEq, Debug)]
12249pub struct DirectoryRouter;
12250
12251impl ::fidl_next::Discoverable for DirectoryRouter {
12252 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
12253}
12254
12255#[cfg(target_os = "fuchsia")]
12256impl ::fidl_next::HasTransport for DirectoryRouter {
12257 type Transport = ::fidl_next::fuchsia::zx::Channel;
12258}
12259
12260pub mod directory_router {
12261 pub mod prelude {
12262 pub use crate::{
12263 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
12264 directory_router,
12265 };
12266
12267 pub use crate::natural::DirectoryRouterRouteResponse;
12268
12269 pub use crate::natural::RouteRequest;
12270
12271 pub use crate::natural::RouterError;
12272 }
12273
12274 pub struct Route;
12275
12276 impl ::fidl_next::Method for Route {
12277 const ORDINAL: u64 = 7510716014181158689;
12278 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12279 ::fidl_next::protocol::Flexibility::Flexible;
12280
12281 type Protocol = crate::DirectoryRouter;
12282
12283 type Request = crate::wire::RouteRequest<'static>;
12284 }
12285
12286 impl ::fidl_next::TwoWayMethod for Route {
12287 type Response = ::fidl_next::WireFlexibleResult<
12288 'static,
12289 crate::wire::DirectoryRouterRouteResponse,
12290 crate::wire::RouterError,
12291 >;
12292 }
12293
12294 impl<___R> ::fidl_next::Respond<___R> for Route {
12295 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12296
12297 fn respond(response: ___R) -> Self::Output {
12298 ::fidl_next::FlexibleResult::Ok(response)
12299 }
12300 }
12301
12302 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12303 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12304
12305 fn respond_err(response: ___R) -> Self::Output {
12306 ::fidl_next::FlexibleResult::Err(response)
12307 }
12308 }
12309
12310 mod ___detail {
12311 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
12312 where
12313 ___T: ::fidl_next::Transport,
12314 {
12315 type Client = DirectoryRouterClient<___T>;
12316 type Server = DirectoryRouterServer<___T>;
12317 }
12318
12319 #[repr(transparent)]
12321 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
12322 #[allow(dead_code)]
12323 client: ::fidl_next::protocol::Client<___T>,
12324 }
12325
12326 impl<___T> DirectoryRouterClient<___T>
12327 where
12328 ___T: ::fidl_next::Transport,
12329 {
12330 pub fn route_with<___R>(
12331 &self,
12332 request: ___R,
12333 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12334 where
12335 ___R: ::fidl_next::Encode<
12336 crate::wire::RouteRequest<'static>,
12337 <___T as ::fidl_next::Transport>::SendBuffer,
12338 >,
12339 {
12340 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12341 7510716014181158689,
12342 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12343 request,
12344 ))
12345 }
12346 }
12347
12348 #[repr(transparent)]
12350 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
12351 server: ::fidl_next::protocol::Server<___T>,
12352 }
12353
12354 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12355 }
12356}
12357
12358pub trait DirectoryRouterClientHandler<
12362 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12363 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12364>
12365{
12366 fn on_unknown_interaction(
12367 &mut self,
12368 ordinal: u64,
12369 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12370 ::core::future::ready(())
12371 }
12372}
12373
12374impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12375where
12376 ___T: ::fidl_next::Transport,
12377{
12378 async fn on_unknown_interaction(&mut self, _: u64) {}
12379}
12380
12381impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
12382where
12383 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
12384 ___T: ::fidl_next::Transport,
12385{
12386 async fn on_event(
12387 handler: &mut ___H,
12388 ordinal: u64,
12389 flexibility: ::fidl_next::protocol::Flexibility,
12390 buffer: ___T::RecvBuffer,
12391 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12392 match ordinal {
12393 ordinal => {
12394 handler.on_unknown_interaction(ordinal).await;
12395 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12396 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12397 } else {
12398 Ok(())
12399 }
12400 }
12401 }
12402 }
12403}
12404
12405pub trait DirectoryRouterServerHandler<
12409 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12410 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12411>
12412{
12413 fn route(
12414 &mut self,
12415
12416 request: ::fidl_next::Request<directory_router::Route, ___T>,
12417
12418 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
12419 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12420
12421 fn on_unknown_interaction(
12422 &mut self,
12423 ordinal: u64,
12424 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12425 ::core::future::ready(())
12426 }
12427}
12428
12429impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
12430where
12431 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
12432 ___T: ::fidl_next::Transport,
12433 <directory_router::Route as ::fidl_next::Method>::Request:
12434 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12435{
12436 async fn on_one_way(
12437 handler: &mut ___H,
12438 ordinal: u64,
12439 flexibility: ::fidl_next::protocol::Flexibility,
12440 buffer: ___T::RecvBuffer,
12441 ) -> ::core::result::Result<
12442 (),
12443 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12444 > {
12445 match ordinal {
12446 ordinal => {
12447 handler.on_unknown_interaction(ordinal).await;
12448 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12449 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12450 } else {
12451 Ok(())
12452 }
12453 }
12454 }
12455 }
12456
12457 async fn on_two_way(
12458 handler: &mut ___H,
12459 ordinal: u64,
12460 flexibility: ::fidl_next::protocol::Flexibility,
12461 buffer: ___T::RecvBuffer,
12462 responder: ::fidl_next::protocol::Responder<___T>,
12463 ) -> ::core::result::Result<
12464 (),
12465 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12466 > {
12467 match ordinal {
12468 7510716014181158689 => {
12469 let responder = ::fidl_next::Responder::from_untyped(responder);
12470
12471 match ::fidl_next::DecoderExt::decode(buffer) {
12472 Ok(decoded) => {
12473 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12474 Ok(())
12475 }
12476 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12477 ordinal: 7510716014181158689,
12478 error,
12479 }),
12480 }
12481 }
12482
12483 ordinal => {
12484 handler.on_unknown_interaction(ordinal).await;
12485 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12486 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12487 } else {
12488 responder
12489 .respond(
12490 ordinal,
12491 flexibility,
12492 ::fidl_next::Flexible::<()>::FrameworkErr(
12493 ::fidl_next::FrameworkError::UnknownMethod,
12494 ),
12495 )
12496 .expect("encoding a framework error should never fail")
12497 .await?;
12498 Ok(())
12499 }
12500 }
12501 }
12502 }
12503}
12504
12505#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
12507#[derive(PartialEq, Debug)]
12508pub struct Receiver;
12509
12510impl ::fidl_next::Discoverable for Receiver {
12511 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
12512}
12513
12514#[cfg(target_os = "fuchsia")]
12515impl ::fidl_next::HasTransport for Receiver {
12516 type Transport = ::fidl_next::fuchsia::zx::Channel;
12517}
12518
12519pub mod receiver {
12520 pub mod prelude {
12521 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
12522
12523 pub use crate::natural::ProtocolPayload;
12524 }
12525
12526 pub struct Receive;
12527
12528 impl ::fidl_next::Method for Receive {
12529 const ORDINAL: u64 = 340832707723008660;
12530 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12531 ::fidl_next::protocol::Flexibility::Flexible;
12532
12533 type Protocol = crate::Receiver;
12534
12535 type Request = crate::wire::ProtocolPayload;
12536 }
12537
12538 mod ___detail {
12539 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
12540 where
12541 ___T: ::fidl_next::Transport,
12542 {
12543 type Client = ReceiverClient<___T>;
12544 type Server = ReceiverServer<___T>;
12545 }
12546
12547 #[repr(transparent)]
12549 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
12550 #[allow(dead_code)]
12551 client: ::fidl_next::protocol::Client<___T>,
12552 }
12553
12554 impl<___T> ReceiverClient<___T>
12555 where
12556 ___T: ::fidl_next::Transport,
12557 {
12558 #[doc = " Sends a channel to this receiver.\n"]
12559 pub fn receive(
12560 &self,
12561
12562 channel: impl ::fidl_next::Encode<
12563 ::fidl_next::fuchsia::WireChannel,
12564 <___T as ::fidl_next::Transport>::SendBuffer,
12565 >,
12566 ) -> ::fidl_next::SendFuture<'_, ___T>
12567 where
12568 <___T as ::fidl_next::Transport>::SendBuffer:
12569 ::fidl_next::encoder::InternalHandleEncoder,
12570 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12571 {
12572 self.receive_with(crate::generic::ProtocolPayload { channel })
12573 }
12574
12575 #[doc = " Sends a channel to this receiver.\n"]
12576 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
12577 where
12578 ___R: ::fidl_next::Encode<
12579 crate::wire::ProtocolPayload,
12580 <___T as ::fidl_next::Transport>::SendBuffer,
12581 >,
12582 {
12583 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
12584 340832707723008660,
12585 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
12586 request,
12587 ))
12588 }
12589 }
12590
12591 #[repr(transparent)]
12593 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
12594 server: ::fidl_next::protocol::Server<___T>,
12595 }
12596
12597 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
12598 }
12599}
12600
12601pub trait ReceiverClientHandler<
12605 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12606 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12607>
12608{
12609 fn on_unknown_interaction(
12610 &mut self,
12611 ordinal: u64,
12612 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12613 ::core::future::ready(())
12614 }
12615}
12616
12617impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
12618where
12619 ___T: ::fidl_next::Transport,
12620{
12621 async fn on_unknown_interaction(&mut self, _: u64) {}
12622}
12623
12624impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
12625where
12626 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
12627 ___T: ::fidl_next::Transport,
12628{
12629 async fn on_event(
12630 handler: &mut ___H,
12631 ordinal: u64,
12632 flexibility: ::fidl_next::protocol::Flexibility,
12633 buffer: ___T::RecvBuffer,
12634 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12635 match ordinal {
12636 ordinal => {
12637 handler.on_unknown_interaction(ordinal).await;
12638 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12639 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12640 } else {
12641 Ok(())
12642 }
12643 }
12644 }
12645 }
12646}
12647
12648pub trait ReceiverServerHandler<
12652 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12653 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12654>
12655{
12656 #[doc = " Sends a channel to this receiver.\n"]
12657 fn receive(
12658 &mut self,
12659
12660 request: ::fidl_next::Request<receiver::Receive, ___T>,
12661 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12662
12663 fn on_unknown_interaction(
12664 &mut self,
12665 ordinal: u64,
12666 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12667 ::core::future::ready(())
12668 }
12669}
12670
12671impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
12672where
12673 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
12674 ___T: ::fidl_next::Transport,
12675 <receiver::Receive as ::fidl_next::Method>::Request:
12676 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12677{
12678 async fn on_one_way(
12679 handler: &mut ___H,
12680 ordinal: u64,
12681 flexibility: ::fidl_next::protocol::Flexibility,
12682 buffer: ___T::RecvBuffer,
12683 ) -> ::core::result::Result<
12684 (),
12685 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12686 > {
12687 match ordinal {
12688 340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
12689 Ok(decoded) => {
12690 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
12691 Ok(())
12692 }
12693 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12694 ordinal: 340832707723008660,
12695 error,
12696 }),
12697 },
12698
12699 ordinal => {
12700 handler.on_unknown_interaction(ordinal).await;
12701 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12702 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12703 } else {
12704 Ok(())
12705 }
12706 }
12707 }
12708 }
12709
12710 async fn on_two_way(
12711 handler: &mut ___H,
12712 ordinal: u64,
12713 flexibility: ::fidl_next::protocol::Flexibility,
12714 buffer: ___T::RecvBuffer,
12715 responder: ::fidl_next::protocol::Responder<___T>,
12716 ) -> ::core::result::Result<
12717 (),
12718 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12719 > {
12720 match ordinal {
12721 ordinal => {
12722 handler.on_unknown_interaction(ordinal).await;
12723 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12724 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12725 } else {
12726 responder
12727 .respond(
12728 ordinal,
12729 flexibility,
12730 ::fidl_next::Flexible::<()>::FrameworkErr(
12731 ::fidl_next::FrameworkError::UnknownMethod,
12732 ),
12733 )
12734 .expect("encoding a framework error should never fail")
12735 .await?;
12736 Ok(())
12737 }
12738 }
12739 }
12740 }
12741}
12742
12743pub use fidl_next_common_fuchsia_component_sandbox::*;
12744
12745pub mod compat {
12747
12748 pub use fidl_next_common_fuchsia_component_sandbox::compat::*;
12749
12750 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
12751 for ::fidl_fuchsia_component_sandbox::DictionaryRef
12752 {
12753 #[inline]
12754 fn compat_from(value: crate::DictionaryRef) -> Self {
12755 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12756 }
12757 }
12758
12759 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
12760 for crate::DictionaryRef
12761 {
12762 #[inline]
12763 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
12764 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12765 }
12766 }
12767
12768 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
12769 #[inline]
12770 fn compat_from(value: crate::Connector) -> Self {
12771 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12772 }
12773 }
12774
12775 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
12776 #[inline]
12777 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
12778 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12779 }
12780 }
12781
12782 impl ::fidl_next::CompatFrom<crate::DirConnector>
12783 for ::fidl_fuchsia_component_sandbox::DirConnector
12784 {
12785 #[inline]
12786 fn compat_from(value: crate::DirConnector) -> Self {
12787 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12788 }
12789 }
12790
12791 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
12792 for crate::DirConnector
12793 {
12794 #[inline]
12795 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
12796 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12797 }
12798 }
12799
12800 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
12801 #[inline]
12802 fn compat_from(value: crate::DirEntry) -> Self {
12803 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12804 }
12805 }
12806
12807 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
12808 #[inline]
12809 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
12810 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
12811 }
12812 }
12813
12814 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
12815 fn compat_from(value: crate::Capability) -> Self {
12816 match value {
12817 crate::Capability::Unit(value) => {
12818 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
12819 }
12820
12821 crate::Capability::Handle(value) => {
12822 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
12823 }
12824
12825 crate::Capability::Data(value) => {
12826 Self::Data(::fidl_next::CompatFrom::compat_from(value))
12827 }
12828
12829 crate::Capability::Dictionary(value) => {
12830 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
12831 }
12832
12833 crate::Capability::Connector(value) => {
12834 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
12835 }
12836
12837 crate::Capability::DirConnector(value) => {
12838 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
12839 }
12840
12841 crate::Capability::Directory(value) => {
12842 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
12843 }
12844
12845 crate::Capability::DirEntry(value) => {
12846 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
12847 }
12848
12849 crate::Capability::ConnectorRouter(value) => {
12850 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12851 }
12852
12853 crate::Capability::DictionaryRouter(value) => {
12854 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
12855 }
12856
12857 crate::Capability::DirEntryRouter(value) => {
12858 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
12859 }
12860
12861 crate::Capability::DataRouter(value) => {
12862 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
12863 }
12864
12865 crate::Capability::DirConnectorRouter(value) => {
12866 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12867 }
12868
12869 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
12870 Self::__SourceBreaking { unknown_ordinal }
12871 }
12872 }
12873 }
12874 }
12875
12876 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
12877 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
12878 match value {
12879 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
12880 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
12881 }
12882
12883 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
12884 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
12885 }
12886
12887 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
12888 Self::Data(::fidl_next::CompatFrom::compat_from(value))
12889 }
12890
12891 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
12892 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
12893 }
12894
12895 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
12896 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
12897 }
12898
12899 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
12900 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
12901 }
12902
12903 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
12904 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
12905 }
12906
12907 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
12908 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
12909 }
12910
12911 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
12912 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12913 }
12914
12915 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
12916 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
12917 }
12918
12919 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
12920 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
12921 }
12922
12923 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
12924 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
12925 }
12926
12927 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
12928 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
12929 }
12930
12931 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
12932 unknown_ordinal,
12933 } => Self::UnknownOrdinal_(unknown_ordinal),
12934 }
12935 }
12936 }
12937
12938 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
12939 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
12940 {
12941 #[inline]
12942 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
12943 Self {
12944 id: ::fidl_next::CompatFrom::compat_from(value.id),
12945
12946 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
12947 }
12948 }
12949 }
12950
12951 impl
12952 ::fidl_next::CompatFrom<
12953 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
12954 > for crate::CapabilityStoreConnectorCreateRequest
12955 {
12956 #[inline]
12957 fn compat_from(
12958 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
12959 ) -> Self {
12960 Self {
12961 id: ::fidl_next::CompatFrom::compat_from(value.id),
12962
12963 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
12964 }
12965 }
12966 }
12967
12968 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
12969 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
12970 {
12971 #[inline]
12972 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
12973 Self {
12974 id: ::fidl_next::CompatFrom::compat_from(value.id),
12975
12976 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12977 }
12978 }
12979 }
12980
12981 impl
12982 ::fidl_next::CompatFrom<
12983 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
12984 > for crate::CapabilityStoreConnectorOpenRequest
12985 {
12986 #[inline]
12987 fn compat_from(
12988 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
12989 ) -> Self {
12990 Self {
12991 id: ::fidl_next::CompatFrom::compat_from(value.id),
12992
12993 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
12994 }
12995 }
12996 }
12997
12998 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
12999 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
13000 {
13001 #[inline]
13002 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
13003 Self {
13004 id: ::fidl_next::CompatFrom::compat_from(value.id),
13005
13006 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13007 }
13008 }
13009 }
13010
13011 impl
13012 ::fidl_next::CompatFrom<
13013 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13014 > for crate::CapabilityStoreDirConnectorCreateRequest
13015 {
13016 #[inline]
13017 fn compat_from(
13018 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13019 ) -> Self {
13020 Self {
13021 id: ::fidl_next::CompatFrom::compat_from(value.id),
13022
13023 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13024 }
13025 }
13026 }
13027
13028 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
13029 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
13030 {
13031 #[inline]
13032 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
13033 Self {
13034 id: ::fidl_next::CompatFrom::compat_from(value.id),
13035
13036 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
13037 }
13038 }
13039 }
13040
13041 impl
13042 ::fidl_next::CompatFrom<
13043 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
13044 > for crate::CapabilityStoreDictionaryLegacyImportRequest
13045 {
13046 #[inline]
13047 fn compat_from(
13048 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
13049 ) -> Self {
13050 Self {
13051 id: ::fidl_next::CompatFrom::compat_from(value.id),
13052
13053 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
13054 }
13055 }
13056 }
13057
13058 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
13059 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
13060 {
13061 #[inline]
13062 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
13063 Self {
13064 id: ::fidl_next::CompatFrom::compat_from(value.id),
13065
13066 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13067 }
13068 }
13069 }
13070
13071 impl
13072 ::fidl_next::CompatFrom<
13073 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
13074 > for crate::CapabilityStoreDictionaryLegacyExportRequest
13075 {
13076 #[inline]
13077 fn compat_from(
13078 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
13079 ) -> Self {
13080 Self {
13081 id: ::fidl_next::CompatFrom::compat_from(value.id),
13082
13083 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13084 }
13085 }
13086 }
13087
13088 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
13089 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
13090 {
13091 #[inline]
13092 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
13093 Self {
13094 id: ::fidl_next::CompatFrom::compat_from(value.id),
13095
13096 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13097 }
13098 }
13099 }
13100
13101 impl
13102 ::fidl_next::CompatFrom<
13103 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
13104 > for crate::CapabilityStoreDictionaryKeysRequest
13105 {
13106 #[inline]
13107 fn compat_from(
13108 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
13109 ) -> Self {
13110 Self {
13111 id: ::fidl_next::CompatFrom::compat_from(value.id),
13112
13113 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13114 }
13115 }
13116 }
13117
13118 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
13119 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
13120 {
13121 #[inline]
13122 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
13123 Self {
13124 id: ::fidl_next::CompatFrom::compat_from(value.id),
13125
13126 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13127 }
13128 }
13129 }
13130
13131 impl
13132 ::fidl_next::CompatFrom<
13133 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
13134 > for crate::CapabilityStoreDictionaryEnumerateRequest
13135 {
13136 #[inline]
13137 fn compat_from(
13138 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
13139 ) -> Self {
13140 Self {
13141 id: ::fidl_next::CompatFrom::compat_from(value.id),
13142
13143 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13144 }
13145 }
13146 }
13147
13148 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
13149 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
13150 {
13151 #[inline]
13152 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
13153 Self {
13154 id: ::fidl_next::CompatFrom::compat_from(value.id),
13155
13156 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13157 }
13158 }
13159 }
13160
13161 impl
13162 ::fidl_next::CompatFrom<
13163 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
13164 > for crate::CapabilityStoreDictionaryDrainRequest
13165 {
13166 #[inline]
13167 fn compat_from(
13168 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
13169 ) -> Self {
13170 Self {
13171 id: ::fidl_next::CompatFrom::compat_from(value.id),
13172
13173 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13174 }
13175 }
13176 }
13177
13178 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
13179 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
13180 {
13181 #[inline]
13182 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
13183 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
13184 }
13185 }
13186
13187 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
13188 for crate::CapabilityStoreExportResponse
13189 {
13190 #[inline]
13191 fn compat_from(
13192 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
13193 ) -> Self {
13194 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
13195 }
13196 }
13197
13198 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
13199 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
13200 {
13201 #[inline]
13202 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
13203 Self {
13204 id: ::fidl_next::CompatFrom::compat_from(value.id),
13205
13206 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
13207 }
13208 }
13209 }
13210
13211 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
13212 for crate::CapabilityStoreImportRequest
13213 {
13214 #[inline]
13215 fn compat_from(
13216 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
13217 ) -> Self {
13218 Self {
13219 id: ::fidl_next::CompatFrom::compat_from(value.id),
13220
13221 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
13222 }
13223 }
13224 }
13225
13226 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
13227 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
13228 {
13229 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
13230 Self {
13231 id: ::fidl_next::CompatFrom::compat_from(value.id),
13232
13233 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13234
13235 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
13236
13237 path: ::fidl_next::CompatFrom::compat_from(value.path),
13238
13239 __source_breaking: ::fidl::marker::SourceBreaking,
13240 }
13241 }
13242 }
13243
13244 impl
13245 ::fidl_next::CompatFrom<
13246 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
13247 > for crate::CapabilityStoreDirConnectorOpenRequest
13248 {
13249 fn compat_from(
13250 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
13251 ) -> Self {
13252 Self {
13253 id: ::fidl_next::CompatFrom::compat_from(value.id),
13254
13255 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13256
13257 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
13258
13259 path: ::fidl_next::CompatFrom::compat_from(value.path),
13260 }
13261 }
13262 }
13263
13264 #[cfg(target_os = "fuchsia")]
13265 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
13268
13269 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
13270 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
13271 {
13272 fn compat_from(_: crate::CapabilityStore) -> Self {
13273 Self
13274 }
13275 }
13276
13277 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
13278 for crate::CapabilityStore
13279 {
13280 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
13281 Self
13282 }
13283 }
13284
13285 #[cfg(target_os = "fuchsia")]
13286
13287 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
13288 for crate::CapabilityStore
13289 {
13290 fn client_compat_from(
13291 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
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::InstanceToken>
13300 for ::fidl_fuchsia_component_sandbox::InstanceToken
13301 {
13302 #[inline]
13303 fn compat_from(value: crate::InstanceToken) -> Self {
13304 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13305 }
13306 }
13307
13308 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
13309 for crate::InstanceToken
13310 {
13311 #[inline]
13312 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
13313 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13314 }
13315 }
13316
13317 impl ::fidl_next::CompatFrom<crate::RouteRequest>
13318 for ::fidl_fuchsia_component_sandbox::RouteRequest
13319 {
13320 fn compat_from(value: crate::RouteRequest) -> Self {
13321 Self {
13322 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
13323
13324 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
13325
13326 __source_breaking: ::fidl::marker::SourceBreaking,
13327 }
13328 }
13329 }
13330
13331 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
13332 for crate::RouteRequest
13333 {
13334 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
13335 Self {
13336 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
13337
13338 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
13339 }
13340 }
13341 }
13342
13343 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
13344 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
13345 {
13346 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
13347 match value {
13348 crate::ConnectorRouterRouteResponse::Connector(value) => {
13349 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
13350 }
13351
13352 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
13353 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13354 }
13355 }
13356 }
13357 }
13358
13359 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
13360 for crate::ConnectorRouterRouteResponse
13361 {
13362 fn compat_from(
13363 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
13364 ) -> Self {
13365 match value {
13366 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
13367 value,
13368 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
13369
13370 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
13371 value,
13372 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13373 }
13374 }
13375 }
13376
13377 #[cfg(target_os = "fuchsia")]
13378 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
13381
13382 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
13383 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
13384 {
13385 fn compat_from(_: crate::ConnectorRouter) -> Self {
13386 Self
13387 }
13388 }
13389
13390 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
13391 for crate::ConnectorRouter
13392 {
13393 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
13394 Self
13395 }
13396 }
13397
13398 #[cfg(target_os = "fuchsia")]
13399
13400 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
13401 for crate::ConnectorRouter
13402 {
13403 fn client_compat_from(
13404 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
13405 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13406 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13407 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13408 ::fidl_next::ClientDispatcher::new(client_end)
13409 }
13410 }
13411
13412 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
13413 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
13414 {
13415 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
13416 match value {
13417 crate::DataRouterRouteResponse::Data(value) => {
13418 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13419 }
13420
13421 crate::DataRouterRouteResponse::Unavailable(value) => {
13422 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13423 }
13424 }
13425 }
13426 }
13427
13428 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
13429 for crate::DataRouterRouteResponse
13430 {
13431 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
13432 match value {
13433 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
13434 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13435 }
13436
13437 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
13438 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13439 }
13440 }
13441 }
13442 }
13443
13444 #[cfg(target_os = "fuchsia")]
13445 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
13448
13449 impl ::fidl_next::CompatFrom<crate::DataRouter>
13450 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
13451 {
13452 fn compat_from(_: crate::DataRouter) -> Self {
13453 Self
13454 }
13455 }
13456
13457 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
13458 for crate::DataRouter
13459 {
13460 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
13461 Self
13462 }
13463 }
13464
13465 #[cfg(target_os = "fuchsia")]
13466
13467 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
13468 for crate::DataRouter
13469 {
13470 fn client_compat_from(
13471 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
13472 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13473 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13474 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13475 ::fidl_next::ClientDispatcher::new(client_end)
13476 }
13477 }
13478
13479 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
13480 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
13481 {
13482 #[inline]
13483 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
13484 Self {
13485 items: ::fidl_next::CompatFrom::compat_from(value.items),
13486
13487 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13488 }
13489 }
13490 }
13491
13492 impl
13493 ::fidl_next::CompatFrom<
13494 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
13495 > for crate::DictionaryDrainIteratorGetNextResponse
13496 {
13497 #[inline]
13498 fn compat_from(
13499 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
13500 ) -> Self {
13501 Self {
13502 items: ::fidl_next::CompatFrom::compat_from(value.items),
13503
13504 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13505 }
13506 }
13507 }
13508
13509 #[cfg(target_os = "fuchsia")]
13510 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
13513
13514 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
13515 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
13516 {
13517 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
13518 Self
13519 }
13520 }
13521
13522 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
13523 for crate::DictionaryDrainIterator
13524 {
13525 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
13526 Self
13527 }
13528 }
13529
13530 #[cfg(target_os = "fuchsia")]
13531
13532 impl
13533 ::fidl_next::ClientCompatFrom<
13534 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
13535 > for crate::DictionaryDrainIterator
13536 {
13537 fn client_compat_from(
13538 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
13539 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13540 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13541 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13542 ::fidl_next::ClientDispatcher::new(client_end)
13543 }
13544 }
13545
13546 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
13547 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
13548 {
13549 #[inline]
13550 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
13551 Self {
13552 key: ::fidl_next::CompatFrom::compat_from(value.key),
13553
13554 value: ::fidl_next::CompatFrom::compat_from(value.value),
13555 }
13556 }
13557 }
13558
13559 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
13560 for crate::DictionaryOptionalItem
13561 {
13562 #[inline]
13563 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
13564 Self {
13565 key: ::fidl_next::CompatFrom::compat_from(value.key),
13566
13567 value: ::fidl_next::CompatFrom::compat_from(value.value),
13568 }
13569 }
13570 }
13571
13572 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
13573 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
13574 {
13575 #[inline]
13576 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
13577 Self {
13578 items: ::fidl_next::CompatFrom::compat_from(value.items),
13579
13580 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13581 }
13582 }
13583 }
13584
13585 impl
13586 ::fidl_next::CompatFrom<
13587 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
13588 > for crate::DictionaryEnumerateIteratorGetNextResponse
13589 {
13590 #[inline]
13591 fn compat_from(
13592 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
13593 ) -> Self {
13594 Self {
13595 items: ::fidl_next::CompatFrom::compat_from(value.items),
13596
13597 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
13598 }
13599 }
13600 }
13601
13602 #[cfg(target_os = "fuchsia")]
13603 pub type DictionaryEnumerateIteratorProxy =
13606 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
13607
13608 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
13609 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
13610 {
13611 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
13612 Self
13613 }
13614 }
13615
13616 impl
13617 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
13618 for crate::DictionaryEnumerateIterator
13619 {
13620 fn compat_from(
13621 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
13622 ) -> Self {
13623 Self
13624 }
13625 }
13626
13627 #[cfg(target_os = "fuchsia")]
13628
13629 impl
13630 ::fidl_next::ClientCompatFrom<
13631 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
13632 > for crate::DictionaryEnumerateIterator
13633 {
13634 fn client_compat_from(
13635 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
13636 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13637 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13638 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13639 ::fidl_next::ClientDispatcher::new(client_end)
13640 }
13641 }
13642
13643 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
13644 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
13645 {
13646 #[inline]
13647 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
13648 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
13649 }
13650 }
13651
13652 impl
13653 ::fidl_next::CompatFrom<
13654 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
13655 > for crate::DictionaryKeysIteratorGetNextResponse
13656 {
13657 #[inline]
13658 fn compat_from(
13659 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
13660 ) -> Self {
13661 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
13662 }
13663 }
13664
13665 #[cfg(target_os = "fuchsia")]
13666 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
13669
13670 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
13671 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
13672 {
13673 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
13674 Self
13675 }
13676 }
13677
13678 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
13679 for crate::DictionaryKeysIterator
13680 {
13681 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
13682 Self
13683 }
13684 }
13685
13686 #[cfg(target_os = "fuchsia")]
13687
13688 impl
13689 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
13690 for crate::DictionaryKeysIterator
13691 {
13692 fn client_compat_from(
13693 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
13694 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13695 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13696 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13697 ::fidl_next::ClientDispatcher::new(client_end)
13698 }
13699 }
13700
13701 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
13702 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
13703 {
13704 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
13705 match value {
13706 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
13707 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
13708 }
13709
13710 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
13711 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13712 }
13713 }
13714 }
13715 }
13716
13717 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
13718 for crate::DictionaryRouterRouteResponse
13719 {
13720 fn compat_from(
13721 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
13722 ) -> Self {
13723 match value {
13724 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
13725 value,
13726 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
13727
13728 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
13729 value,
13730 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13731 }
13732 }
13733 }
13734
13735 #[cfg(target_os = "fuchsia")]
13736 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
13739
13740 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
13741 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
13742 {
13743 fn compat_from(_: crate::DictionaryRouter) -> Self {
13744 Self
13745 }
13746 }
13747
13748 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
13749 for crate::DictionaryRouter
13750 {
13751 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
13752 Self
13753 }
13754 }
13755
13756 #[cfg(target_os = "fuchsia")]
13757
13758 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
13759 for crate::DictionaryRouter
13760 {
13761 fn client_compat_from(
13762 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
13763 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13764 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13765 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13766 ::fidl_next::ClientDispatcher::new(client_end)
13767 }
13768 }
13769
13770 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
13771 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
13772 {
13773 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
13774 match value {
13775 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
13776 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
13777 }
13778
13779 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
13780 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13781 }
13782 }
13783 }
13784 }
13785
13786 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
13787 for crate::DirConnectorRouterRouteResponse
13788 {
13789 fn compat_from(
13790 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
13791 ) -> Self {
13792 match value {
13793 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
13794 value,
13795 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
13796
13797 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
13798 value,
13799 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13800 }
13801 }
13802 }
13803
13804 #[cfg(target_os = "fuchsia")]
13805 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
13808
13809 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
13810 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
13811 {
13812 fn compat_from(_: crate::DirConnectorRouter) -> Self {
13813 Self
13814 }
13815 }
13816
13817 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
13818 for crate::DirConnectorRouter
13819 {
13820 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
13821 Self
13822 }
13823 }
13824
13825 #[cfg(target_os = "fuchsia")]
13826
13827 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
13828 for crate::DirConnectorRouter
13829 {
13830 fn client_compat_from(
13831 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
13832 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13833 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13834 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13835 ::fidl_next::ClientDispatcher::new(client_end)
13836 }
13837 }
13838
13839 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
13840 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
13841 {
13842 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
13843 match value {
13844 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
13845 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13846 }
13847
13848 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
13849 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13850 }
13851 }
13852 }
13853 }
13854
13855 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
13856 for crate::DirEntryRouterRouteResponse
13857 {
13858 fn compat_from(
13859 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
13860 ) -> Self {
13861 match value {
13862 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
13863 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13864 }
13865
13866 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
13867 value,
13868 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
13869 }
13870 }
13871 }
13872
13873 #[cfg(target_os = "fuchsia")]
13874 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
13877
13878 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
13879 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
13880 {
13881 fn compat_from(_: crate::DirEntryRouter) -> Self {
13882 Self
13883 }
13884 }
13885
13886 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
13887 for crate::DirEntryRouter
13888 {
13889 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
13890 Self
13891 }
13892 }
13893
13894 #[cfg(target_os = "fuchsia")]
13895
13896 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
13897 for crate::DirEntryRouter
13898 {
13899 fn client_compat_from(
13900 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
13901 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13902 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13903 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13904 ::fidl_next::ClientDispatcher::new(client_end)
13905 }
13906 }
13907
13908 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
13909 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
13910 {
13911 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
13912 Self {
13913 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
13914
13915 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
13916
13917 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
13918
13919 __source_breaking: ::fidl::marker::SourceBreaking,
13920 }
13921 }
13922 }
13923
13924 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
13925 for crate::DirReceiverReceiveRequest
13926 {
13927 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
13928 Self {
13929 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
13930
13931 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
13932
13933 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
13934 }
13935 }
13936 }
13937
13938 #[cfg(target_os = "fuchsia")]
13939 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
13942
13943 impl ::fidl_next::CompatFrom<crate::DirReceiver>
13944 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
13945 {
13946 fn compat_from(_: crate::DirReceiver) -> Self {
13947 Self
13948 }
13949 }
13950
13951 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
13952 for crate::DirReceiver
13953 {
13954 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
13955 Self
13956 }
13957 }
13958
13959 #[cfg(target_os = "fuchsia")]
13960
13961 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
13962 for crate::DirReceiver
13963 {
13964 fn client_compat_from(
13965 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
13966 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
13967 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
13968 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
13969 ::fidl_next::ClientDispatcher::new(client_end)
13970 }
13971 }
13972
13973 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
13974 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
13975 {
13976 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
13977 match value {
13978 crate::DirectoryRouterRouteResponse::Directory(value) => {
13979 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
13980 }
13981
13982 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
13983 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
13984 }
13985 }
13986 }
13987 }
13988
13989 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
13990 for crate::DirectoryRouterRouteResponse
13991 {
13992 fn compat_from(
13993 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
13994 ) -> Self {
13995 match value {
13996 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
13997 value,
13998 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
13999
14000 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
14001 value,
14002 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14003 }
14004 }
14005 }
14006
14007 #[cfg(target_os = "fuchsia")]
14008 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
14011
14012 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
14013 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
14014 {
14015 fn compat_from(_: crate::DirectoryRouter) -> Self {
14016 Self
14017 }
14018 }
14019
14020 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
14021 for crate::DirectoryRouter
14022 {
14023 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
14024 Self
14025 }
14026 }
14027
14028 #[cfg(target_os = "fuchsia")]
14029
14030 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
14031 for crate::DirectoryRouter
14032 {
14033 fn client_compat_from(
14034 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
14035 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14036 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14037 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14038 ::fidl_next::ClientDispatcher::new(client_end)
14039 }
14040 }
14041
14042 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
14043 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
14044 {
14045 #[inline]
14046 fn compat_from(value: crate::ProtocolPayload) -> Self {
14047 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
14048 }
14049 }
14050
14051 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
14052 for crate::ProtocolPayload
14053 {
14054 #[inline]
14055 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
14056 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
14057 }
14058 }
14059
14060 #[cfg(target_os = "fuchsia")]
14061 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
14064
14065 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
14066 fn compat_from(_: crate::Receiver) -> Self {
14067 Self
14068 }
14069 }
14070
14071 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
14072 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
14073 Self
14074 }
14075 }
14076
14077 #[cfg(target_os = "fuchsia")]
14078
14079 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
14080 for crate::Receiver
14081 {
14082 fn client_compat_from(
14083 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
14084 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14085 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14086 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14087 ::fidl_next::ClientDispatcher::new(client_end)
14088 }
14089 }
14090}