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(Debug, PartialEq)]
13 #[repr(C)]
14 pub struct DirConnector {
15 pub token: ::fidl_next::fuchsia::zx::EventPair,
16 }
17
18 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector
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::DirConnector> = 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::DirConnector>,
38 _: (),
39 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
40 ::fidl_next::munge! {
41 let crate::wire::DirConnector {
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::DirConnector>, ___E>
57 for DirConnector
58 where
59 ___E: ::fidl_next::Encoder + ?Sized,
60 DirConnector: ::fidl_next::Encode<crate::wire::DirConnector, ___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::DirConnector>,
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::DirConnector> for DirConnector {
83 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirConnector, 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::DirConnector) -> Self {
94 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
95 }
96 }
97
98 #[derive(Debug, Default, PartialEq)]
99 pub struct AggregateSource {
100 pub dir_connector: ::core::option::Option<crate::natural::DirConnector>,
101
102 pub source_instance_filter: ::core::option::Option<::std::vec::Vec<::std::string::String>>,
103
104 pub renamed_instances: ::core::option::Option<
105 ::std::vec::Vec<::fidl_next_fuchsia_component_decl::natural::NameMapping>,
106 >,
107 }
108
109 impl AggregateSource {
110 fn __max_ordinal(&self) -> usize {
111 if self.renamed_instances.is_some() {
112 return 3;
113 }
114
115 if self.source_instance_filter.is_some() {
116 return 2;
117 }
118
119 if self.dir_connector.is_some() {
120 return 1;
121 }
122
123 0
124 }
125 }
126
127 unsafe impl<___E> ::fidl_next::Encode<crate::wire::AggregateSource<'static>, ___E>
128 for AggregateSource
129 where
130 ___E: ::fidl_next::Encoder + ?Sized,
131 ___E: ::fidl_next::fuchsia::HandleEncoder,
132 {
133 #[inline]
134 fn encode(
135 mut self,
136 encoder: &mut ___E,
137 out: &mut ::core::mem::MaybeUninit<crate::wire::AggregateSource<'static>>,
138 _: (),
139 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
140 ::fidl_next::munge!(let crate::wire::AggregateSource { table } = out);
141
142 let max_ord = self.__max_ordinal();
143
144 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
145 ::fidl_next::Wire::zero_padding(&mut out);
146
147 let mut preallocated =
148 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
149
150 for i in 1..=max_ord {
151 match i {
152 3 => {
153 if let Some(value) = self.renamed_instances.take() {
154 ::fidl_next::WireEnvelope::encode_value::<
155 ::fidl_next::WireVector<
156 'static,
157 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'static>,
158 >,
159 ___E,
160 >(
161 value, preallocated.encoder, &mut out, (4294967295, ())
162 )?;
163 } else {
164 ::fidl_next::WireEnvelope::encode_zero(&mut out)
165 }
166 }
167
168 2 => {
169 if let Some(value) = self.source_instance_filter.take() {
170 ::fidl_next::WireEnvelope::encode_value::<
171 ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
172 ___E,
173 >(
174 value, preallocated.encoder, &mut out, (4294967295, 255)
175 )?;
176 } else {
177 ::fidl_next::WireEnvelope::encode_zero(&mut out)
178 }
179 }
180
181 1 => {
182 if let Some(value) = self.dir_connector.take() {
183 ::fidl_next::WireEnvelope::encode_value::<
184 crate::wire::DirConnector,
185 ___E,
186 >(
187 value, preallocated.encoder, &mut out, ()
188 )?;
189 } else {
190 ::fidl_next::WireEnvelope::encode_zero(&mut out)
191 }
192 }
193
194 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
195 }
196 unsafe {
197 preallocated.write_next(out.assume_init_ref());
198 }
199 }
200
201 ::fidl_next::WireTable::encode_len(table, max_ord);
202
203 Ok(())
204 }
205 }
206
207 impl<'de> ::fidl_next::FromWire<crate::wire::AggregateSource<'de>> for AggregateSource {
208 #[inline]
209 fn from_wire(wire_: crate::wire::AggregateSource<'de>) -> Self {
210 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
211
212 let dir_connector = wire_.table.get(1);
213
214 let source_instance_filter = wire_.table.get(2);
215
216 let renamed_instances = wire_.table.get(3);
217
218 Self {
219
220
221 dir_connector: dir_connector.map(|envelope| ::fidl_next::FromWire::from_wire(
222 unsafe { envelope.read_unchecked::<crate::wire::DirConnector>() }
223 )),
224
225
226 source_instance_filter: source_instance_filter.map(|envelope| ::fidl_next::FromWire::from_wire(
227 unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>() }
228 )),
229
230
231 renamed_instances: renamed_instances.map(|envelope| ::fidl_next::FromWire::from_wire(
232 unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>>>() }
233 )),
234
235 }
236 }
237 }
238
239 #[derive(Debug, PartialEq)]
240 #[repr(C)]
241 pub struct DictionaryRef {
242 pub token: ::fidl_next::fuchsia::zx::EventPair,
243 }
244
245 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef
246 where
247 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
248 ___E: ::fidl_next::fuchsia::HandleEncoder,
249 {
250 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DictionaryRef> = unsafe {
251 ::fidl_next::CopyOptimization::enable_if(
252 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
253 ::fidl_next::fuchsia::WireEventPair,
254 ___E,
255 >>::COPY_OPTIMIZATION
256 .is_enabled(),
257 )
258 };
259
260 #[inline]
261 fn encode(
262 self,
263 encoder_: &mut ___E,
264 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
265 _: (),
266 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
267 ::fidl_next::munge! {
268 let crate::wire::DictionaryRef {
269 token,
270
271 } = out_;
272 }
273
274 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
275
276 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
277
278 Ok(())
279 }
280 }
281
282 unsafe impl<___E>
283 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::DictionaryRef>, ___E>
284 for DictionaryRef
285 where
286 ___E: ::fidl_next::Encoder + ?Sized,
287 DictionaryRef: ::fidl_next::Encode<crate::wire::DictionaryRef, ___E>,
288 {
289 #[inline]
290 fn encode_option(
291 this: ::core::option::Option<Self>,
292 encoder: &mut ___E,
293 out: &mut ::core::mem::MaybeUninit<
294 ::fidl_next::WireBox<'static, crate::wire::DictionaryRef>,
295 >,
296 _: (),
297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
298 if let Some(inner) = this {
299 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
300 ::fidl_next::WireBox::encode_present(out);
301 } else {
302 ::fidl_next::WireBox::encode_absent(out);
303 }
304
305 Ok(())
306 }
307 }
308
309 impl ::fidl_next::FromWire<crate::wire::DictionaryRef> for DictionaryRef {
310 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DictionaryRef, Self> = unsafe {
311 ::fidl_next::CopyOptimization::enable_if(
312 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
313 ::fidl_next::fuchsia::WireEventPair,
314 >>::COPY_OPTIMIZATION
315 .is_enabled(),
316 )
317 };
318
319 #[inline]
320 fn from_wire(wire: crate::wire::DictionaryRef) -> Self {
321 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
322 }
323 }
324
325 #[derive(Debug, PartialEq)]
326 #[repr(C)]
327 pub struct Connector {
328 pub token: ::fidl_next::fuchsia::zx::EventPair,
329 }
330
331 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector
332 where
333 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
334 ___E: ::fidl_next::fuchsia::HandleEncoder,
335 {
336 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Connector> = unsafe {
337 ::fidl_next::CopyOptimization::enable_if(
338 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
339 ::fidl_next::fuchsia::WireEventPair,
340 ___E,
341 >>::COPY_OPTIMIZATION
342 .is_enabled(),
343 )
344 };
345
346 #[inline]
347 fn encode(
348 self,
349 encoder_: &mut ___E,
350 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
351 _: (),
352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
353 ::fidl_next::munge! {
354 let crate::wire::Connector {
355 token,
356
357 } = out_;
358 }
359
360 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
361
362 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
363
364 Ok(())
365 }
366 }
367
368 unsafe impl<___E>
369 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Connector>, ___E>
370 for Connector
371 where
372 ___E: ::fidl_next::Encoder + ?Sized,
373 Connector: ::fidl_next::Encode<crate::wire::Connector, ___E>,
374 {
375 #[inline]
376 fn encode_option(
377 this: ::core::option::Option<Self>,
378 encoder: &mut ___E,
379 out: &mut ::core::mem::MaybeUninit<
380 ::fidl_next::WireBox<'static, crate::wire::Connector>,
381 >,
382 _: (),
383 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
384 if let Some(inner) = this {
385 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
386 ::fidl_next::WireBox::encode_present(out);
387 } else {
388 ::fidl_next::WireBox::encode_absent(out);
389 }
390
391 Ok(())
392 }
393 }
394
395 impl ::fidl_next::FromWire<crate::wire::Connector> for Connector {
396 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Connector, Self> = unsafe {
397 ::fidl_next::CopyOptimization::enable_if(
398 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
399 ::fidl_next::fuchsia::WireEventPair,
400 >>::COPY_OPTIMIZATION
401 .is_enabled(),
402 )
403 };
404
405 #[inline]
406 fn from_wire(wire: crate::wire::Connector) -> Self {
407 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
408 }
409 }
410
411 #[derive(Debug, PartialEq)]
412 #[repr(C)]
413 pub struct DirEntry {
414 pub token: ::fidl_next::fuchsia::zx::EventPair,
415 }
416
417 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry
418 where
419 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
420 ___E: ::fidl_next::fuchsia::HandleEncoder,
421 {
422 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirEntry> = unsafe {
423 ::fidl_next::CopyOptimization::enable_if(
424 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
425 ::fidl_next::fuchsia::WireEventPair,
426 ___E,
427 >>::COPY_OPTIMIZATION
428 .is_enabled(),
429 )
430 };
431
432 #[inline]
433 fn encode(
434 self,
435 encoder_: &mut ___E,
436 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
437 _: (),
438 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
439 ::fidl_next::munge! {
440 let crate::wire::DirEntry {
441 token,
442
443 } = out_;
444 }
445
446 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
447
448 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
449
450 Ok(())
451 }
452 }
453
454 unsafe impl<___E>
455 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::DirEntry>, ___E>
456 for DirEntry
457 where
458 ___E: ::fidl_next::Encoder + ?Sized,
459 DirEntry: ::fidl_next::Encode<crate::wire::DirEntry, ___E>,
460 {
461 #[inline]
462 fn encode_option(
463 this: ::core::option::Option<Self>,
464 encoder: &mut ___E,
465 out: &mut ::core::mem::MaybeUninit<
466 ::fidl_next::WireBox<'static, crate::wire::DirEntry>,
467 >,
468 _: (),
469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
470 if let Some(inner) = this {
471 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
472 ::fidl_next::WireBox::encode_present(out);
473 } else {
474 ::fidl_next::WireBox::encode_absent(out);
475 }
476
477 Ok(())
478 }
479 }
480
481 impl ::fidl_next::FromWire<crate::wire::DirEntry> for DirEntry {
482 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirEntry, Self> = unsafe {
483 ::fidl_next::CopyOptimization::enable_if(
484 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
485 ::fidl_next::fuchsia::WireEventPair,
486 >>::COPY_OPTIMIZATION
487 .is_enabled(),
488 )
489 };
490
491 #[inline]
492 fn from_wire(wire: crate::wire::DirEntry) -> Self {
493 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
494 }
495 }
496
497 #[derive(Debug, PartialEq)]
498 pub enum Capability {
499 Unit(crate::natural::Unit),
500
501 Handle(::fidl_next::fuchsia::zx::NullableHandle),
502
503 Data(crate::natural::Data),
504
505 Dictionary(crate::natural::DictionaryRef),
506
507 Connector(crate::natural::Connector),
508
509 DirConnector(crate::natural::DirConnector),
510
511 Directory(
512 ::fidl_next::ClientEnd<
513 ::fidl_next_fuchsia_io::Directory,
514 ::fidl_next::fuchsia::zx::Channel,
515 >,
516 ),
517
518 DirEntry(crate::natural::DirEntry),
519
520 ConnectorRouter(
521 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
522 ),
523
524 DictionaryRouter(
525 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
526 ),
527
528 DirEntryRouter(
529 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
530 ),
531
532 DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
533
534 DirConnectorRouter(
535 ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
536 ),
537
538 UnknownOrdinal_(u64),
539 }
540
541 impl Capability {
542 pub fn is_unknown(&self) -> bool {
543 #[allow(unreachable_patterns)]
544 match self {
545 Self::UnknownOrdinal_(_) => true,
546 _ => false,
547 }
548 }
549 }
550
551 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability<'static>, ___E> for Capability
552 where
553 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
554 ___E: ::fidl_next::Encoder,
555 ___E: ::fidl_next::fuchsia::HandleEncoder,
556 {
557 #[inline]
558 fn encode(
559 self,
560 encoder: &mut ___E,
561 out: &mut ::core::mem::MaybeUninit<crate::wire::Capability<'static>>,
562 _: (),
563 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
564 ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);
565
566 match self {
567 Self::Unit(value) => {
568 ::fidl_next::RawWireUnion::encode_as::<___E, crate::wire::Unit>(
569 value,
570 1,
571 encoder,
572 raw,
573 (),
574 )?
575 }
576
577 Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
578 ___E,
579 ::fidl_next::fuchsia::WireNullableHandle,
580 >(value, 2, encoder, raw, ())?,
581
582 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
583 ___E,
584 crate::wire::Data<'static>,
585 >(value, 3, encoder, raw, ())?,
586
587 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
588 ___E,
589 crate::wire::DictionaryRef,
590 >(value, 4, encoder, raw, ())?,
591
592 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as::<
593 ___E,
594 crate::wire::Connector,
595 >(value, 5, encoder, raw, ())?,
596
597 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
598 ___E,
599 crate::wire::DirConnector,
600 >(value, 6, encoder, raw, ())?,
601
602 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
603 ___E,
604 ::fidl_next::ClientEnd<
605 ::fidl_next_fuchsia_io::Directory,
606 ::fidl_next::fuchsia::WireChannel,
607 >,
608 >(value, 7, encoder, raw, ())?,
609
610 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<
611 ___E,
612 crate::wire::DirEntry,
613 >(value, 8, encoder, raw, ())?,
614
615 Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
616 ___E,
617 ::fidl_next::ClientEnd<
618 crate::ConnectorRouter,
619 ::fidl_next::fuchsia::WireChannel,
620 >,
621 >(value, 9, encoder, raw, ())?,
622
623 Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
624 ___E,
625 ::fidl_next::ClientEnd<
626 crate::DictionaryRouter,
627 ::fidl_next::fuchsia::WireChannel,
628 >,
629 >(value, 10, encoder, raw, ())?,
630
631 Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
632 ___E,
633 ::fidl_next::ClientEnd<
634 crate::DirEntryRouter,
635 ::fidl_next::fuchsia::WireChannel,
636 >,
637 >(value, 11, encoder, raw, ())?,
638
639 Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
640 ___E,
641 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
642 >(value, 12, encoder, raw, ())?,
643
644 Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
645 ___E,
646 ::fidl_next::ClientEnd<
647 crate::DirConnectorRouter,
648 ::fidl_next::fuchsia::WireChannel,
649 >,
650 >(value, 13, encoder, raw, ())?,
651
652 Self::UnknownOrdinal_(ordinal) => {
653 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
654 }
655 }
656
657 Ok(())
658 }
659 }
660
661 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Capability<'static>, ___E>
662 for Capability
663 where
664 ___E: ?Sized,
665 Capability: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
666 {
667 #[inline]
668 fn encode_option(
669 this: ::core::option::Option<Self>,
670 encoder: &mut ___E,
671 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Capability<'static>>,
672 _: (),
673 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
674 ::fidl_next::munge!(let crate::wire_optional::Capability { raw, _phantom: _ } = &mut *out);
675
676 if let Some(inner) = this {
677 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
678 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
679 } else {
680 ::fidl_next::RawWireUnion::encode_absent(raw);
681 }
682
683 Ok(())
684 }
685 }
686
687 impl<'de> ::fidl_next::FromWire<crate::wire::Capability<'de>> for Capability {
688 #[inline]
689 fn from_wire(wire: crate::wire::Capability<'de>) -> Self {
690 let wire = ::core::mem::ManuallyDrop::new(wire);
691 match wire.raw.ordinal() {
692 1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
693 wire.raw.get().read_unchecked::<crate::wire::Unit>()
694 })),
695
696 2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
697 wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
698 })),
699
700 3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
701 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
702 })),
703
704 4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
705 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
706 })),
707
708 5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
709 wire.raw.get().read_unchecked::<crate::wire::Connector>()
710 })),
711
712 6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
713 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
714 })),
715
716 7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
717 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
718 ::fidl_next_fuchsia_io::Directory,
719 ::fidl_next::fuchsia::WireChannel,
720 >>()
721 })),
722
723 8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
724 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
725 })),
726
727 9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
728 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
729 crate::ConnectorRouter,
730 ::fidl_next::fuchsia::WireChannel,
731 >>()
732 })),
733
734 10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
735 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
736 crate::DictionaryRouter,
737 ::fidl_next::fuchsia::WireChannel,
738 >>()
739 })),
740
741 11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
742 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
743 crate::DirEntryRouter,
744 ::fidl_next::fuchsia::WireChannel,
745 >>()
746 })),
747
748 12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
749 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
750 })),
751
752 13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
753 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
754 crate::DirConnectorRouter,
755 ::fidl_next::fuchsia::WireChannel,
756 >>()
757 })),
758
759 ord => return Self::UnknownOrdinal_(ord as u64),
760 }
761 }
762 }
763
764 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Capability {
765 #[inline]
766 fn from_wire_option(
767 wire: crate::wire_optional::Capability<'de>,
768 ) -> ::core::option::Option<Self> {
769 if let Some(inner) = wire.into_option() {
770 Some(::fidl_next::FromWire::from_wire(inner))
771 } else {
772 None
773 }
774 }
775 }
776
777 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
778 #[inline]
779 fn from_wire_option(
780 wire: crate::wire_optional::Capability<'de>,
781 ) -> ::core::option::Option<Self> {
782 <
783 Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
784 >::from_wire_option(wire).map(Box::new)
785 }
786 }
787
788 #[derive(Debug, PartialEq)]
789 pub struct CapabilityStoreConnectorCreateRequest {
790 pub id: u64,
791
792 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
793 }
794
795 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
796 for CapabilityStoreConnectorCreateRequest
797 where
798 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
799 ___E: ::fidl_next::fuchsia::HandleEncoder,
800 {
801 #[inline]
802 fn encode(
803 self,
804 encoder_: &mut ___E,
805 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
806 _: (),
807 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
808 ::fidl_next::munge! {
809 let crate::wire::CapabilityStoreConnectorCreateRequest {
810 id,
811 receiver,
812
813 } = out_;
814 }
815
816 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
817
818 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
819
820 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
821
822 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
823
824 Ok(())
825 }
826 }
827
828 unsafe impl<___E>
829 ::fidl_next::EncodeOption<
830 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
831 ___E,
832 > for CapabilityStoreConnectorCreateRequest
833 where
834 ___E: ::fidl_next::Encoder + ?Sized,
835 CapabilityStoreConnectorCreateRequest:
836 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>,
837 {
838 #[inline]
839 fn encode_option(
840 this: ::core::option::Option<Self>,
841 encoder: &mut ___E,
842 out: &mut ::core::mem::MaybeUninit<
843 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
844 >,
845 _: (),
846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
847 if let Some(inner) = this {
848 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
849 ::fidl_next::WireBox::encode_present(out);
850 } else {
851 ::fidl_next::WireBox::encode_absent(out);
852 }
853
854 Ok(())
855 }
856 }
857
858 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateRequest>
859 for CapabilityStoreConnectorCreateRequest
860 {
861 #[inline]
862 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateRequest) -> Self {
863 Self {
864 id: ::fidl_next::FromWire::from_wire(wire.id),
865
866 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
867 }
868 }
869 }
870
871 #[derive(Debug, PartialEq)]
872 pub struct CapabilityStoreConnectorOpenRequest {
873 pub id: u64,
874
875 pub server_end: ::fidl_next::fuchsia::zx::Channel,
876 }
877
878 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
879 for CapabilityStoreConnectorOpenRequest
880 where
881 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
882 ___E: ::fidl_next::fuchsia::HandleEncoder,
883 {
884 #[inline]
885 fn encode(
886 self,
887 encoder_: &mut ___E,
888 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
889 _: (),
890 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
891 ::fidl_next::munge! {
892 let crate::wire::CapabilityStoreConnectorOpenRequest {
893 id,
894 server_end,
895
896 } = out_;
897 }
898
899 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
900
901 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
902
903 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
904
905 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
906
907 Ok(())
908 }
909 }
910
911 unsafe impl<___E>
912 ::fidl_next::EncodeOption<
913 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
914 ___E,
915 > for CapabilityStoreConnectorOpenRequest
916 where
917 ___E: ::fidl_next::Encoder + ?Sized,
918 CapabilityStoreConnectorOpenRequest:
919 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>,
920 {
921 #[inline]
922 fn encode_option(
923 this: ::core::option::Option<Self>,
924 encoder: &mut ___E,
925 out: &mut ::core::mem::MaybeUninit<
926 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
927 >,
928 _: (),
929 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
930 if let Some(inner) = this {
931 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
932 ::fidl_next::WireBox::encode_present(out);
933 } else {
934 ::fidl_next::WireBox::encode_absent(out);
935 }
936
937 Ok(())
938 }
939 }
940
941 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenRequest>
942 for CapabilityStoreConnectorOpenRequest
943 {
944 #[inline]
945 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenRequest) -> Self {
946 Self {
947 id: ::fidl_next::FromWire::from_wire(wire.id),
948
949 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
950 }
951 }
952 }
953
954 #[derive(Debug, PartialEq)]
955 pub struct CapabilityStoreDirConnectorCreateRequest {
956 pub id: u64,
957
958 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
959 }
960
961 unsafe impl<___E>
962 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
963 for CapabilityStoreDirConnectorCreateRequest
964 where
965 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
966 ___E: ::fidl_next::fuchsia::HandleEncoder,
967 {
968 #[inline]
969 fn encode(
970 self,
971 encoder_: &mut ___E,
972 out_: &mut ::core::mem::MaybeUninit<
973 crate::wire::CapabilityStoreDirConnectorCreateRequest,
974 >,
975 _: (),
976 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
977 ::fidl_next::munge! {
978 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
979 id,
980 receiver,
981
982 } = out_;
983 }
984
985 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
986
987 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
988
989 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
990
991 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
992
993 Ok(())
994 }
995 }
996
997 unsafe impl<___E>
998 ::fidl_next::EncodeOption<
999 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>,
1000 ___E,
1001 > for CapabilityStoreDirConnectorCreateRequest
1002 where
1003 ___E: ::fidl_next::Encoder + ?Sized,
1004 CapabilityStoreDirConnectorCreateRequest:
1005 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>,
1006 {
1007 #[inline]
1008 fn encode_option(
1009 this: ::core::option::Option<Self>,
1010 encoder: &mut ___E,
1011 out: &mut ::core::mem::MaybeUninit<
1012 ::fidl_next::WireBox<
1013 'static,
1014 crate::wire::CapabilityStoreDirConnectorCreateRequest,
1015 >,
1016 >,
1017 _: (),
1018 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1019 if let Some(inner) = this {
1020 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1021 ::fidl_next::WireBox::encode_present(out);
1022 } else {
1023 ::fidl_next::WireBox::encode_absent(out);
1024 }
1025
1026 Ok(())
1027 }
1028 }
1029
1030 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
1031 for CapabilityStoreDirConnectorCreateRequest
1032 {
1033 #[inline]
1034 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
1035 Self {
1036 id: ::fidl_next::FromWire::from_wire(wire.id),
1037
1038 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
1039 }
1040 }
1041 }
1042
1043 #[derive(Debug, PartialEq)]
1044 pub struct CapabilityStoreDictionaryLegacyImportRequest {
1045 pub id: u64,
1046
1047 pub client_end: ::fidl_next::fuchsia::zx::Channel,
1048 }
1049
1050 unsafe impl<___E>
1051 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
1052 for CapabilityStoreDictionaryLegacyImportRequest
1053 where
1054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1055 ___E: ::fidl_next::fuchsia::HandleEncoder,
1056 {
1057 #[inline]
1058 fn encode(
1059 self,
1060 encoder_: &mut ___E,
1061 out_: &mut ::core::mem::MaybeUninit<
1062 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1063 >,
1064 _: (),
1065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1066 ::fidl_next::munge! {
1067 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
1068 id,
1069 client_end,
1070
1071 } = out_;
1072 }
1073
1074 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1075
1076 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1077
1078 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
1079
1080 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
1081
1082 Ok(())
1083 }
1084 }
1085
1086 unsafe impl<___E>
1087 ::fidl_next::EncodeOption<
1088 ::fidl_next::WireBox<
1089 'static,
1090 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1091 >,
1092 ___E,
1093 > for CapabilityStoreDictionaryLegacyImportRequest
1094 where
1095 ___E: ::fidl_next::Encoder + ?Sized,
1096 CapabilityStoreDictionaryLegacyImportRequest:
1097 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>,
1098 {
1099 #[inline]
1100 fn encode_option(
1101 this: ::core::option::Option<Self>,
1102 encoder: &mut ___E,
1103 out: &mut ::core::mem::MaybeUninit<
1104 ::fidl_next::WireBox<
1105 'static,
1106 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1107 >,
1108 >,
1109 _: (),
1110 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1111 if let Some(inner) = this {
1112 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1113 ::fidl_next::WireBox::encode_present(out);
1114 } else {
1115 ::fidl_next::WireBox::encode_absent(out);
1116 }
1117
1118 Ok(())
1119 }
1120 }
1121
1122 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
1123 for CapabilityStoreDictionaryLegacyImportRequest
1124 {
1125 #[inline]
1126 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
1127 Self {
1128 id: ::fidl_next::FromWire::from_wire(wire.id),
1129
1130 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
1131 }
1132 }
1133 }
1134
1135 #[derive(Debug, PartialEq)]
1136 pub struct CapabilityStoreDictionaryLegacyExportRequest {
1137 pub id: u64,
1138
1139 pub server_end: ::fidl_next::fuchsia::zx::Channel,
1140 }
1141
1142 unsafe impl<___E>
1143 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
1144 for CapabilityStoreDictionaryLegacyExportRequest
1145 where
1146 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1147 ___E: ::fidl_next::fuchsia::HandleEncoder,
1148 {
1149 #[inline]
1150 fn encode(
1151 self,
1152 encoder_: &mut ___E,
1153 out_: &mut ::core::mem::MaybeUninit<
1154 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1155 >,
1156 _: (),
1157 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1158 ::fidl_next::munge! {
1159 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
1160 id,
1161 server_end,
1162
1163 } = out_;
1164 }
1165
1166 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1167
1168 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1169
1170 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
1171
1172 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
1173
1174 Ok(())
1175 }
1176 }
1177
1178 unsafe impl<___E>
1179 ::fidl_next::EncodeOption<
1180 ::fidl_next::WireBox<
1181 'static,
1182 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1183 >,
1184 ___E,
1185 > for CapabilityStoreDictionaryLegacyExportRequest
1186 where
1187 ___E: ::fidl_next::Encoder + ?Sized,
1188 CapabilityStoreDictionaryLegacyExportRequest:
1189 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>,
1190 {
1191 #[inline]
1192 fn encode_option(
1193 this: ::core::option::Option<Self>,
1194 encoder: &mut ___E,
1195 out: &mut ::core::mem::MaybeUninit<
1196 ::fidl_next::WireBox<
1197 'static,
1198 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1199 >,
1200 >,
1201 _: (),
1202 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1203 if let Some(inner) = this {
1204 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1205 ::fidl_next::WireBox::encode_present(out);
1206 } else {
1207 ::fidl_next::WireBox::encode_absent(out);
1208 }
1209
1210 Ok(())
1211 }
1212 }
1213
1214 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
1215 for CapabilityStoreDictionaryLegacyExportRequest
1216 {
1217 #[inline]
1218 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
1219 Self {
1220 id: ::fidl_next::FromWire::from_wire(wire.id),
1221
1222 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
1223 }
1224 }
1225 }
1226
1227 #[derive(Debug, PartialEq)]
1228 pub struct CapabilityStoreDictionaryKeysRequest {
1229 pub id: u64,
1230
1231 pub iterator: ::fidl_next::ServerEnd<
1232 crate::DictionaryKeysIterator,
1233 ::fidl_next::fuchsia::zx::Channel,
1234 >,
1235 }
1236
1237 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
1238 for CapabilityStoreDictionaryKeysRequest
1239 where
1240 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1241 ___E: ::fidl_next::fuchsia::HandleEncoder,
1242 {
1243 #[inline]
1244 fn encode(
1245 self,
1246 encoder_: &mut ___E,
1247 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
1248 _: (),
1249 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1250 ::fidl_next::munge! {
1251 let crate::wire::CapabilityStoreDictionaryKeysRequest {
1252 id,
1253 iterator,
1254
1255 } = out_;
1256 }
1257
1258 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1259
1260 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1261
1262 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1263
1264 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1265
1266 Ok(())
1267 }
1268 }
1269
1270 unsafe impl<___E>
1271 ::fidl_next::EncodeOption<
1272 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1273 ___E,
1274 > for CapabilityStoreDictionaryKeysRequest
1275 where
1276 ___E: ::fidl_next::Encoder + ?Sized,
1277 CapabilityStoreDictionaryKeysRequest:
1278 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>,
1279 {
1280 #[inline]
1281 fn encode_option(
1282 this: ::core::option::Option<Self>,
1283 encoder: &mut ___E,
1284 out: &mut ::core::mem::MaybeUninit<
1285 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1286 >,
1287 _: (),
1288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1289 if let Some(inner) = this {
1290 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1291 ::fidl_next::WireBox::encode_present(out);
1292 } else {
1293 ::fidl_next::WireBox::encode_absent(out);
1294 }
1295
1296 Ok(())
1297 }
1298 }
1299
1300 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
1301 for CapabilityStoreDictionaryKeysRequest
1302 {
1303 #[inline]
1304 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
1305 Self {
1306 id: ::fidl_next::FromWire::from_wire(wire.id),
1307
1308 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1309 }
1310 }
1311 }
1312
1313 #[derive(Debug, PartialEq)]
1314 pub struct CapabilityStoreDictionaryEnumerateRequest {
1315 pub id: u64,
1316
1317 pub iterator: ::fidl_next::ServerEnd<
1318 crate::DictionaryEnumerateIterator,
1319 ::fidl_next::fuchsia::zx::Channel,
1320 >,
1321 }
1322
1323 unsafe impl<___E>
1324 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
1325 for CapabilityStoreDictionaryEnumerateRequest
1326 where
1327 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1328 ___E: ::fidl_next::fuchsia::HandleEncoder,
1329 {
1330 #[inline]
1331 fn encode(
1332 self,
1333 encoder_: &mut ___E,
1334 out_: &mut ::core::mem::MaybeUninit<
1335 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1336 >,
1337 _: (),
1338 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1339 ::fidl_next::munge! {
1340 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
1341 id,
1342 iterator,
1343
1344 } = out_;
1345 }
1346
1347 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1348
1349 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1350
1351 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1352
1353 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1354
1355 Ok(())
1356 }
1357 }
1358
1359 unsafe impl<___E>
1360 ::fidl_next::EncodeOption<
1361 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>,
1362 ___E,
1363 > for CapabilityStoreDictionaryEnumerateRequest
1364 where
1365 ___E: ::fidl_next::Encoder + ?Sized,
1366 CapabilityStoreDictionaryEnumerateRequest:
1367 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>,
1368 {
1369 #[inline]
1370 fn encode_option(
1371 this: ::core::option::Option<Self>,
1372 encoder: &mut ___E,
1373 out: &mut ::core::mem::MaybeUninit<
1374 ::fidl_next::WireBox<
1375 'static,
1376 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1377 >,
1378 >,
1379 _: (),
1380 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1381 if let Some(inner) = this {
1382 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1383 ::fidl_next::WireBox::encode_present(out);
1384 } else {
1385 ::fidl_next::WireBox::encode_absent(out);
1386 }
1387
1388 Ok(())
1389 }
1390 }
1391
1392 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
1393 for CapabilityStoreDictionaryEnumerateRequest
1394 {
1395 #[inline]
1396 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
1397 Self {
1398 id: ::fidl_next::FromWire::from_wire(wire.id),
1399
1400 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1401 }
1402 }
1403 }
1404
1405 #[derive(Debug, PartialEq)]
1406 pub struct CapabilityStoreDictionaryDrainRequest {
1407 pub id: u64,
1408
1409 pub iterator: ::core::option::Option<
1410 ::fidl_next::ServerEnd<
1411 crate::DictionaryDrainIterator,
1412 ::fidl_next::fuchsia::zx::Channel,
1413 >,
1414 >,
1415 }
1416
1417 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
1418 for CapabilityStoreDictionaryDrainRequest
1419 where
1420 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1421 ___E: ::fidl_next::fuchsia::HandleEncoder,
1422 {
1423 #[inline]
1424 fn encode(
1425 self,
1426 encoder_: &mut ___E,
1427 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
1428 _: (),
1429 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1430 ::fidl_next::munge! {
1431 let crate::wire::CapabilityStoreDictionaryDrainRequest {
1432 id,
1433 iterator,
1434
1435 } = out_;
1436 }
1437
1438 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1439
1440 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1441
1442 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1443
1444 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1445
1446 Ok(())
1447 }
1448 }
1449
1450 unsafe impl<___E>
1451 ::fidl_next::EncodeOption<
1452 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1453 ___E,
1454 > for CapabilityStoreDictionaryDrainRequest
1455 where
1456 ___E: ::fidl_next::Encoder + ?Sized,
1457 CapabilityStoreDictionaryDrainRequest:
1458 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>,
1459 {
1460 #[inline]
1461 fn encode_option(
1462 this: ::core::option::Option<Self>,
1463 encoder: &mut ___E,
1464 out: &mut ::core::mem::MaybeUninit<
1465 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1466 >,
1467 _: (),
1468 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1469 if let Some(inner) = this {
1470 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1471 ::fidl_next::WireBox::encode_present(out);
1472 } else {
1473 ::fidl_next::WireBox::encode_absent(out);
1474 }
1475
1476 Ok(())
1477 }
1478 }
1479
1480 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
1481 for CapabilityStoreDictionaryDrainRequest
1482 {
1483 #[inline]
1484 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
1485 Self {
1486 id: ::fidl_next::FromWire::from_wire(wire.id),
1487
1488 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1489 }
1490 }
1491 }
1492
1493 #[derive(Debug, PartialEq)]
1494 pub struct CapabilityStoreCreateServiceAggregateRequest {
1495 pub sources: ::std::vec::Vec<crate::natural::AggregateSource>,
1496 }
1497
1498 unsafe impl<___E>
1499 ::fidl_next::Encode<
1500 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1501 ___E,
1502 > for CapabilityStoreCreateServiceAggregateRequest
1503 where
1504 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1505 ___E: ::fidl_next::Encoder,
1506 ___E: ::fidl_next::fuchsia::HandleEncoder,
1507 {
1508 #[inline]
1509 fn encode(
1510 self,
1511 encoder_: &mut ___E,
1512 out_: &mut ::core::mem::MaybeUninit<
1513 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1514 >,
1515 _: (),
1516 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1517 ::fidl_next::munge! {
1518 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
1519 sources,
1520
1521 } = out_;
1522 }
1523
1524 ::fidl_next::Encode::encode(self.sources, encoder_, sources, (4294967295, ()))?;
1525
1526 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sources.as_mut_ptr()) };
1527 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1528
1529 Ok(())
1530 }
1531 }
1532
1533 unsafe impl<___E>
1534 ::fidl_next::EncodeOption<
1535 ::fidl_next::WireBox<
1536 'static,
1537 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1538 >,
1539 ___E,
1540 > for CapabilityStoreCreateServiceAggregateRequest
1541 where
1542 ___E: ::fidl_next::Encoder + ?Sized,
1543 CapabilityStoreCreateServiceAggregateRequest: ::fidl_next::Encode<
1544 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1545 ___E,
1546 >,
1547 {
1548 #[inline]
1549 fn encode_option(
1550 this: ::core::option::Option<Self>,
1551 encoder: &mut ___E,
1552 out: &mut ::core::mem::MaybeUninit<
1553 ::fidl_next::WireBox<
1554 'static,
1555 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1556 >,
1557 >,
1558 _: (),
1559 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1560 if let Some(inner) = this {
1561 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1562 ::fidl_next::WireBox::encode_present(out);
1563 } else {
1564 ::fidl_next::WireBox::encode_absent(out);
1565 }
1566
1567 Ok(())
1568 }
1569 }
1570
1571 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>>
1572 for CapabilityStoreCreateServiceAggregateRequest
1573 {
1574 #[inline]
1575 fn from_wire(wire: crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>) -> Self {
1576 Self { sources: ::fidl_next::FromWire::from_wire(wire.sources) }
1577 }
1578 }
1579
1580 #[derive(Debug, PartialEq)]
1581 #[repr(C)]
1582 pub struct CapabilityStoreCreateServiceAggregateResponse {
1583 pub aggregate_dir_connector: crate::natural::DirConnector,
1584 }
1585
1586 unsafe impl<___E>
1587 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
1588 for CapabilityStoreCreateServiceAggregateResponse
1589 where
1590 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1591 ___E: ::fidl_next::fuchsia::HandleEncoder,
1592 {
1593 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1594 Self,
1595 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1596 > = unsafe {
1597 ::fidl_next::CopyOptimization::enable_if(
1598 true && <crate::natural::DirConnector as ::fidl_next::Encode<
1599 crate::wire::DirConnector,
1600 ___E,
1601 >>::COPY_OPTIMIZATION
1602 .is_enabled(),
1603 )
1604 };
1605
1606 #[inline]
1607 fn encode(
1608 self,
1609 encoder_: &mut ___E,
1610 out_: &mut ::core::mem::MaybeUninit<
1611 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1612 >,
1613 _: (),
1614 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1615 ::fidl_next::munge! {
1616 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
1617 aggregate_dir_connector,
1618
1619 } = out_;
1620 }
1621
1622 ::fidl_next::Encode::encode(
1623 self.aggregate_dir_connector,
1624 encoder_,
1625 aggregate_dir_connector,
1626 (),
1627 )?;
1628
1629 let mut _field =
1630 unsafe { ::fidl_next::Slot::new_unchecked(aggregate_dir_connector.as_mut_ptr()) };
1631
1632 Ok(())
1633 }
1634 }
1635
1636 unsafe impl<___E>
1637 ::fidl_next::EncodeOption<
1638 ::fidl_next::WireBox<
1639 'static,
1640 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1641 >,
1642 ___E,
1643 > for CapabilityStoreCreateServiceAggregateResponse
1644 where
1645 ___E: ::fidl_next::Encoder + ?Sized,
1646 CapabilityStoreCreateServiceAggregateResponse:
1647 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>,
1648 {
1649 #[inline]
1650 fn encode_option(
1651 this: ::core::option::Option<Self>,
1652 encoder: &mut ___E,
1653 out: &mut ::core::mem::MaybeUninit<
1654 ::fidl_next::WireBox<
1655 'static,
1656 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1657 >,
1658 >,
1659 _: (),
1660 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1661 if let Some(inner) = this {
1662 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1663 ::fidl_next::WireBox::encode_present(out);
1664 } else {
1665 ::fidl_next::WireBox::encode_absent(out);
1666 }
1667
1668 Ok(())
1669 }
1670 }
1671
1672 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreCreateServiceAggregateResponse>
1673 for CapabilityStoreCreateServiceAggregateResponse
1674 {
1675 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1676 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1677 Self,
1678 > = unsafe {
1679 ::fidl_next::CopyOptimization::enable_if(
1680 true && <crate::natural::DirConnector as ::fidl_next::FromWire<
1681 crate::wire::DirConnector,
1682 >>::COPY_OPTIMIZATION
1683 .is_enabled(),
1684 )
1685 };
1686
1687 #[inline]
1688 fn from_wire(wire: crate::wire::CapabilityStoreCreateServiceAggregateResponse) -> Self {
1689 Self {
1690 aggregate_dir_connector: ::fidl_next::FromWire::from_wire(
1691 wire.aggregate_dir_connector,
1692 ),
1693 }
1694 }
1695 }
1696
1697 #[derive(Debug, PartialEq)]
1698 pub struct CapabilityStoreExportResponse {
1699 pub capability: crate::natural::Capability,
1700 }
1701
1702 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
1703 for CapabilityStoreExportResponse
1704 where
1705 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1706 ___E: ::fidl_next::Encoder,
1707 ___E: ::fidl_next::fuchsia::HandleEncoder,
1708 {
1709 #[inline]
1710 fn encode(
1711 self,
1712 encoder_: &mut ___E,
1713 out_: &mut ::core::mem::MaybeUninit<
1714 crate::wire::CapabilityStoreExportResponse<'static>,
1715 >,
1716 _: (),
1717 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1718 ::fidl_next::munge! {
1719 let crate::wire::CapabilityStoreExportResponse {
1720 capability,
1721
1722 } = out_;
1723 }
1724
1725 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1726
1727 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1728
1729 Ok(())
1730 }
1731 }
1732
1733 unsafe impl<___E>
1734 ::fidl_next::EncodeOption<
1735 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1736 ___E,
1737 > for CapabilityStoreExportResponse
1738 where
1739 ___E: ::fidl_next::Encoder + ?Sized,
1740 CapabilityStoreExportResponse:
1741 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>,
1742 {
1743 #[inline]
1744 fn encode_option(
1745 this: ::core::option::Option<Self>,
1746 encoder: &mut ___E,
1747 out: &mut ::core::mem::MaybeUninit<
1748 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1749 >,
1750 _: (),
1751 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1752 if let Some(inner) = this {
1753 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1754 ::fidl_next::WireBox::encode_present(out);
1755 } else {
1756 ::fidl_next::WireBox::encode_absent(out);
1757 }
1758
1759 Ok(())
1760 }
1761 }
1762
1763 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
1764 for CapabilityStoreExportResponse
1765 {
1766 #[inline]
1767 fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
1768 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
1769 }
1770 }
1771
1772 #[derive(Debug, PartialEq)]
1773 pub struct CapabilityStoreImportRequest {
1774 pub id: u64,
1775
1776 pub capability: crate::natural::Capability,
1777 }
1778
1779 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
1780 for CapabilityStoreImportRequest
1781 where
1782 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1783 ___E: ::fidl_next::Encoder,
1784 ___E: ::fidl_next::fuchsia::HandleEncoder,
1785 {
1786 #[inline]
1787 fn encode(
1788 self,
1789 encoder_: &mut ___E,
1790 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 ::fidl_next::munge! {
1794 let crate::wire::CapabilityStoreImportRequest {
1795 id,
1796 capability,
1797
1798 } = out_;
1799 }
1800
1801 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1802
1803 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1804
1805 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1806
1807 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1808
1809 Ok(())
1810 }
1811 }
1812
1813 unsafe impl<___E>
1814 ::fidl_next::EncodeOption<
1815 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1816 ___E,
1817 > for CapabilityStoreImportRequest
1818 where
1819 ___E: ::fidl_next::Encoder + ?Sized,
1820 CapabilityStoreImportRequest:
1821 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>,
1822 {
1823 #[inline]
1824 fn encode_option(
1825 this: ::core::option::Option<Self>,
1826 encoder: &mut ___E,
1827 out: &mut ::core::mem::MaybeUninit<
1828 ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1829 >,
1830 _: (),
1831 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1832 if let Some(inner) = this {
1833 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1834 ::fidl_next::WireBox::encode_present(out);
1835 } else {
1836 ::fidl_next::WireBox::encode_absent(out);
1837 }
1838
1839 Ok(())
1840 }
1841 }
1842
1843 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
1844 for CapabilityStoreImportRequest
1845 {
1846 #[inline]
1847 fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
1848 Self {
1849 id: ::fidl_next::FromWire::from_wire(wire.id),
1850
1851 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1852 }
1853 }
1854 }
1855
1856 #[derive(Debug, Default, PartialEq)]
1857 pub struct CapabilityStoreDirConnectorOpenRequest {
1858 pub id: ::core::option::Option<u64>,
1859
1860 pub server_end: ::core::option::Option<
1861 ::fidl_next::ServerEnd<
1862 ::fidl_next_fuchsia_io::Directory,
1863 ::fidl_next::fuchsia::zx::Channel,
1864 >,
1865 >,
1866
1867 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
1868
1869 pub path: ::core::option::Option<::std::string::String>,
1870 }
1871
1872 impl CapabilityStoreDirConnectorOpenRequest {
1873 fn __max_ordinal(&self) -> usize {
1874 if self.path.is_some() {
1875 return 4;
1876 }
1877
1878 if self.flags.is_some() {
1879 return 3;
1880 }
1881
1882 if self.server_end.is_some() {
1883 return 2;
1884 }
1885
1886 if self.id.is_some() {
1887 return 1;
1888 }
1889
1890 0
1891 }
1892 }
1893
1894 unsafe impl<___E>
1895 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>, ___E>
1896 for CapabilityStoreDirConnectorOpenRequest
1897 where
1898 ___E: ::fidl_next::Encoder + ?Sized,
1899 ___E: ::fidl_next::fuchsia::HandleEncoder,
1900 {
1901 #[inline]
1902 fn encode(
1903 mut self,
1904 encoder: &mut ___E,
1905 out: &mut ::core::mem::MaybeUninit<
1906 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
1907 >,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge!(let crate::wire::CapabilityStoreDirConnectorOpenRequest { table } = out);
1911
1912 let max_ord = self.__max_ordinal();
1913
1914 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
1915 ::fidl_next::Wire::zero_padding(&mut out);
1916
1917 let mut preallocated =
1918 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
1919
1920 for i in 1..=max_ord {
1921 match i {
1922 4 => {
1923 if let Some(value) = self.path.take() {
1924 ::fidl_next::WireEnvelope::encode_value::<
1925 ::fidl_next::WireString<'static>,
1926 ___E,
1927 >(
1928 value, preallocated.encoder, &mut out, 4095
1929 )?;
1930 } else {
1931 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1932 }
1933 }
1934
1935 3 => {
1936 if let Some(value) = self.flags.take() {
1937 ::fidl_next::WireEnvelope::encode_value::<
1938 ::fidl_next_fuchsia_io::wire::Flags,
1939 ___E,
1940 >(
1941 value, preallocated.encoder, &mut out, ()
1942 )?;
1943 } else {
1944 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1945 }
1946 }
1947
1948 2 => {
1949 if let Some(value) = self.server_end.take() {
1950 ::fidl_next::WireEnvelope::encode_value::<
1951 ::fidl_next::ServerEnd<
1952 ::fidl_next_fuchsia_io::Directory,
1953 ::fidl_next::fuchsia::WireChannel,
1954 >,
1955 ___E,
1956 >(
1957 value, preallocated.encoder, &mut out, ()
1958 )?;
1959 } else {
1960 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1961 }
1962 }
1963
1964 1 => {
1965 if let Some(value) = self.id.take() {
1966 ::fidl_next::WireEnvelope::encode_value::<::fidl_next::WireU64, ___E>(
1967 value,
1968 preallocated.encoder,
1969 &mut out,
1970 (),
1971 )?;
1972 } else {
1973 ::fidl_next::WireEnvelope::encode_zero(&mut out)
1974 }
1975 }
1976
1977 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
1978 }
1979 unsafe {
1980 preallocated.write_next(out.assume_init_ref());
1981 }
1982 }
1983
1984 ::fidl_next::WireTable::encode_len(table, max_ord);
1985
1986 Ok(())
1987 }
1988 }
1989
1990 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>>
1991 for CapabilityStoreDirConnectorOpenRequest
1992 {
1993 #[inline]
1994 fn from_wire(wire_: crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>) -> Self {
1995 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1996
1997 let id = wire_.table.get(1);
1998
1999 let server_end = wire_.table.get(2);
2000
2001 let flags = wire_.table.get(3);
2002
2003 let path = wire_.table.get(4);
2004
2005 Self {
2006 id: id.map(|envelope| {
2007 ::fidl_next::FromWire::from_wire(unsafe {
2008 envelope.read_unchecked::<::fidl_next::WireU64>()
2009 })
2010 }),
2011
2012 server_end: server_end.map(|envelope| {
2013 ::fidl_next::FromWire::from_wire(unsafe {
2014 envelope.read_unchecked::<::fidl_next::ServerEnd<
2015 ::fidl_next_fuchsia_io::Directory,
2016 ::fidl_next::fuchsia::WireChannel,
2017 >>()
2018 })
2019 }),
2020
2021 flags: flags.map(|envelope| {
2022 ::fidl_next::FromWire::from_wire(unsafe {
2023 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
2024 })
2025 }),
2026
2027 path: path.map(|envelope| {
2028 ::fidl_next::FromWire::from_wire(unsafe {
2029 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
2030 })
2031 }),
2032 }
2033 }
2034 }
2035
2036 #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
2037 #[derive(Debug, PartialEq)]
2038 #[repr(C)]
2039 pub struct InstanceToken {
2040 pub token: ::fidl_next::fuchsia::zx::EventPair,
2041 }
2042
2043 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken
2044 where
2045 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2046 ___E: ::fidl_next::fuchsia::HandleEncoder,
2047 {
2048 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
2049 ::fidl_next::CopyOptimization::enable_if(
2050 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2051 ::fidl_next::fuchsia::WireEventPair,
2052 ___E,
2053 >>::COPY_OPTIMIZATION
2054 .is_enabled(),
2055 )
2056 };
2057
2058 #[inline]
2059 fn encode(
2060 self,
2061 encoder_: &mut ___E,
2062 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
2063 _: (),
2064 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2065 ::fidl_next::munge! {
2066 let crate::wire::InstanceToken {
2067 token,
2068
2069 } = out_;
2070 }
2071
2072 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
2073
2074 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<___E>
2081 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::InstanceToken>, ___E>
2082 for InstanceToken
2083 where
2084 ___E: ::fidl_next::Encoder + ?Sized,
2085 InstanceToken: ::fidl_next::Encode<crate::wire::InstanceToken, ___E>,
2086 {
2087 #[inline]
2088 fn encode_option(
2089 this: ::core::option::Option<Self>,
2090 encoder: &mut ___E,
2091 out: &mut ::core::mem::MaybeUninit<
2092 ::fidl_next::WireBox<'static, crate::wire::InstanceToken>,
2093 >,
2094 _: (),
2095 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2096 if let Some(inner) = this {
2097 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2098 ::fidl_next::WireBox::encode_present(out);
2099 } else {
2100 ::fidl_next::WireBox::encode_absent(out);
2101 }
2102
2103 Ok(())
2104 }
2105 }
2106
2107 impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
2108 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
2109 ::fidl_next::CopyOptimization::enable_if(
2110 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2111 ::fidl_next::fuchsia::WireEventPair,
2112 >>::COPY_OPTIMIZATION
2113 .is_enabled(),
2114 )
2115 };
2116
2117 #[inline]
2118 fn from_wire(wire: crate::wire::InstanceToken) -> Self {
2119 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
2120 }
2121 }
2122
2123 #[doc = " A request for a route.\n"]
2124 #[derive(Debug, Default, PartialEq)]
2125 pub struct RouteRequest {
2126 pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
2127
2128 pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
2129 }
2130
2131 impl RouteRequest {
2132 fn __max_ordinal(&self) -> usize {
2133 if self.metadata.is_some() {
2134 return 2;
2135 }
2136
2137 if self.requesting.is_some() {
2138 return 1;
2139 }
2140
2141 0
2142 }
2143 }
2144
2145 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouteRequest<'static>, ___E> for RouteRequest
2146 where
2147 ___E: ::fidl_next::Encoder + ?Sized,
2148 ___E: ::fidl_next::fuchsia::HandleEncoder,
2149 {
2150 #[inline]
2151 fn encode(
2152 mut self,
2153 encoder: &mut ___E,
2154 out: &mut ::core::mem::MaybeUninit<crate::wire::RouteRequest<'static>>,
2155 _: (),
2156 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2157 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
2158
2159 let max_ord = self.__max_ordinal();
2160
2161 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
2162 ::fidl_next::Wire::zero_padding(&mut out);
2163
2164 let mut preallocated =
2165 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
2166
2167 for i in 1..=max_ord {
2168 match i {
2169 2 => {
2170 if let Some(value) = self.metadata.take() {
2171 ::fidl_next::WireEnvelope::encode_value::<
2172 crate::wire::DictionaryRef,
2173 ___E,
2174 >(
2175 value, preallocated.encoder, &mut out, ()
2176 )?;
2177 } else {
2178 ::fidl_next::WireEnvelope::encode_zero(&mut out)
2179 }
2180 }
2181
2182 1 => {
2183 if let Some(value) = self.requesting.take() {
2184 ::fidl_next::WireEnvelope::encode_value::<
2185 crate::wire::InstanceToken,
2186 ___E,
2187 >(
2188 value, preallocated.encoder, &mut out, ()
2189 )?;
2190 } else {
2191 ::fidl_next::WireEnvelope::encode_zero(&mut out)
2192 }
2193 }
2194
2195 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
2196 }
2197 unsafe {
2198 preallocated.write_next(out.assume_init_ref());
2199 }
2200 }
2201
2202 ::fidl_next::WireTable::encode_len(table, max_ord);
2203
2204 Ok(())
2205 }
2206 }
2207
2208 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
2209 #[inline]
2210 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
2211 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2212
2213 let requesting = wire_.table.get(1);
2214
2215 let metadata = wire_.table.get(2);
2216
2217 Self {
2218 requesting: requesting.map(|envelope| {
2219 ::fidl_next::FromWire::from_wire(unsafe {
2220 envelope.read_unchecked::<crate::wire::InstanceToken>()
2221 })
2222 }),
2223
2224 metadata: metadata.map(|envelope| {
2225 ::fidl_next::FromWire::from_wire(unsafe {
2226 envelope.read_unchecked::<crate::wire::DictionaryRef>()
2227 })
2228 }),
2229 }
2230 }
2231 }
2232
2233 #[derive(Debug, PartialEq)]
2234 pub enum ConnectorRouterRouteResponse {
2235 Connector(crate::natural::Connector),
2236
2237 Unavailable(crate::natural::Unit),
2238 }
2239
2240 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>
2241 for ConnectorRouterRouteResponse
2242 where
2243 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2244 ___E: ::fidl_next::fuchsia::HandleEncoder,
2245 {
2246 #[inline]
2247 fn encode(
2248 self,
2249 encoder: &mut ___E,
2250 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectorRouterRouteResponse>,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2254
2255 match self {
2256 Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2257 ___E,
2258 crate::wire::Connector,
2259 >(value, 1, encoder, raw, ())?,
2260
2261 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2262 ___E,
2263 crate::wire::Unit,
2264 >(value, 2, encoder, raw, ())?,
2265 }
2266
2267 Ok(())
2268 }
2269 }
2270
2271 unsafe impl<___E>
2272 ::fidl_next::EncodeOption<crate::wire_optional::ConnectorRouterRouteResponse, ___E>
2273 for ConnectorRouterRouteResponse
2274 where
2275 ___E: ?Sized,
2276 ConnectorRouterRouteResponse:
2277 ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>,
2278 {
2279 #[inline]
2280 fn encode_option(
2281 this: ::core::option::Option<Self>,
2282 encoder: &mut ___E,
2283 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConnectorRouterRouteResponse>,
2284 _: (),
2285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2286 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2287
2288 if let Some(inner) = this {
2289 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2290 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2291 } else {
2292 ::fidl_next::RawWireUnion::encode_absent(raw);
2293 }
2294
2295 Ok(())
2296 }
2297 }
2298
2299 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
2300 for ConnectorRouterRouteResponse
2301 {
2302 #[inline]
2303 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
2304 let wire = ::core::mem::ManuallyDrop::new(wire);
2305 match wire.raw.ordinal() {
2306 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
2307 wire.raw.get().read_unchecked::<crate::wire::Connector>()
2308 })),
2309
2310 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2311 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2312 })),
2313
2314 _ => unsafe { ::core::hint::unreachable_unchecked() },
2315 }
2316 }
2317 }
2318
2319 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2320 for ConnectorRouterRouteResponse
2321 {
2322 #[inline]
2323 fn from_wire_option(
2324 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2325 ) -> ::core::option::Option<Self> {
2326 if let Some(inner) = wire.into_option() {
2327 Some(::fidl_next::FromWire::from_wire(inner))
2328 } else {
2329 None
2330 }
2331 }
2332 }
2333
2334 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2335 for Box<ConnectorRouterRouteResponse>
2336 {
2337 #[inline]
2338 fn from_wire_option(
2339 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2340 ) -> ::core::option::Option<Self> {
2341 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
2342 crate::wire_optional::ConnectorRouterRouteResponse,
2343 >>::from_wire_option(wire)
2344 .map(Box::new)
2345 }
2346 }
2347
2348 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2349 pub enum DataRouterRouteResponse {
2350 Data(crate::natural::Data),
2351
2352 Unavailable(crate::natural::Unit),
2353 }
2354
2355 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>
2356 for DataRouterRouteResponse
2357 where
2358 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2359 ___E: ::fidl_next::Encoder,
2360 ___E: ::fidl_next::fuchsia::HandleEncoder,
2361 {
2362 #[inline]
2363 fn encode(
2364 self,
2365 encoder: &mut ___E,
2366 out: &mut ::core::mem::MaybeUninit<crate::wire::DataRouterRouteResponse<'static>>,
2367 _: (),
2368 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2369 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
2370
2371 match self {
2372 Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
2373 ___E,
2374 crate::wire::Data<'static>,
2375 >(value, 1, encoder, raw, ())?,
2376
2377 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as::<
2378 ___E,
2379 crate::wire::Unit,
2380 >(value, 2, encoder, raw, ())?,
2381 }
2382
2383 Ok(())
2384 }
2385 }
2386
2387 unsafe impl<___E>
2388 ::fidl_next::EncodeOption<crate::wire_optional::DataRouterRouteResponse<'static>, ___E>
2389 for DataRouterRouteResponse
2390 where
2391 ___E: ?Sized,
2392 DataRouterRouteResponse:
2393 ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>,
2394 {
2395 #[inline]
2396 fn encode_option(
2397 this: ::core::option::Option<Self>,
2398 encoder: &mut ___E,
2399 out: &mut ::core::mem::MaybeUninit<
2400 crate::wire_optional::DataRouterRouteResponse<'static>,
2401 >,
2402 _: (),
2403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2404 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2405
2406 if let Some(inner) = this {
2407 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2408 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2409 } else {
2410 ::fidl_next::RawWireUnion::encode_absent(raw);
2411 }
2412
2413 Ok(())
2414 }
2415 }
2416
2417 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
2418 for DataRouterRouteResponse
2419 {
2420 #[inline]
2421 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
2422 let wire = ::core::mem::ManuallyDrop::new(wire);
2423 match wire.raw.ordinal() {
2424 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
2425 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
2426 })),
2427
2428 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2429 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2430 })),
2431
2432 _ => unsafe { ::core::hint::unreachable_unchecked() },
2433 }
2434 }
2435 }
2436
2437 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2438 for DataRouterRouteResponse
2439 {
2440 #[inline]
2441 fn from_wire_option(
2442 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2443 ) -> ::core::option::Option<Self> {
2444 if let Some(inner) = wire.into_option() {
2445 Some(::fidl_next::FromWire::from_wire(inner))
2446 } else {
2447 None
2448 }
2449 }
2450 }
2451
2452 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2453 for Box<DataRouterRouteResponse>
2454 {
2455 #[inline]
2456 fn from_wire_option(
2457 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2458 ) -> ::core::option::Option<Self> {
2459 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
2460 crate::wire_optional::DataRouterRouteResponse<'de>,
2461 >>::from_wire_option(wire)
2462 .map(Box::new)
2463 }
2464 }
2465
2466 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2467 pub struct DictionaryDrainIteratorGetNextResponse {
2468 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
2469
2470 pub end_id: u64,
2471 }
2472
2473 unsafe impl<___E>
2474 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
2475 for DictionaryDrainIteratorGetNextResponse
2476 where
2477 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2478 ___E: ::fidl_next::Encoder,
2479 ___E: ::fidl_next::fuchsia::HandleEncoder,
2480 {
2481 #[inline]
2482 fn encode(
2483 self,
2484 encoder_: &mut ___E,
2485 out_: &mut ::core::mem::MaybeUninit<
2486 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2487 >,
2488 _: (),
2489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2490 ::fidl_next::munge! {
2491 let crate::wire::DictionaryDrainIteratorGetNextResponse {
2492 items,
2493 end_id,
2494
2495 } = out_;
2496 }
2497
2498 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2499
2500 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2501 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2502
2503 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2504
2505 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2506
2507 Ok(())
2508 }
2509 }
2510
2511 unsafe impl<___E>
2512 ::fidl_next::EncodeOption<
2513 ::fidl_next::WireBox<
2514 'static,
2515 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2516 >,
2517 ___E,
2518 > for DictionaryDrainIteratorGetNextResponse
2519 where
2520 ___E: ::fidl_next::Encoder + ?Sized,
2521 DictionaryDrainIteratorGetNextResponse:
2522 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>,
2523 {
2524 #[inline]
2525 fn encode_option(
2526 this: ::core::option::Option<Self>,
2527 encoder: &mut ___E,
2528 out: &mut ::core::mem::MaybeUninit<
2529 ::fidl_next::WireBox<
2530 'static,
2531 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2532 >,
2533 >,
2534 _: (),
2535 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2536 if let Some(inner) = this {
2537 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2538 ::fidl_next::WireBox::encode_present(out);
2539 } else {
2540 ::fidl_next::WireBox::encode_absent(out);
2541 }
2542
2543 Ok(())
2544 }
2545 }
2546
2547 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
2548 for DictionaryDrainIteratorGetNextResponse
2549 {
2550 #[inline]
2551 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
2552 Self {
2553 items: ::fidl_next::FromWire::from_wire(wire.items),
2554
2555 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2556 }
2557 }
2558 }
2559
2560 #[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"]
2561 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2562 pub struct DictionaryOptionalItem {
2563 pub key: ::std::string::String,
2564
2565 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
2566 }
2567
2568 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
2569 for DictionaryOptionalItem
2570 where
2571 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2572 ___E: ::fidl_next::Encoder,
2573 ___E: ::fidl_next::fuchsia::HandleEncoder,
2574 {
2575 #[inline]
2576 fn encode(
2577 self,
2578 encoder_: &mut ___E,
2579 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
2580 _: (),
2581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2582 ::fidl_next::munge! {
2583 let crate::wire::DictionaryOptionalItem {
2584 key,
2585 value,
2586
2587 } = out_;
2588 }
2589
2590 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2591
2592 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2593 ::fidl_next::Constrained::validate(_field, 255)?;
2594
2595 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2596
2597 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2598
2599 Ok(())
2600 }
2601 }
2602
2603 unsafe impl<___E>
2604 ::fidl_next::EncodeOption<
2605 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2606 ___E,
2607 > for DictionaryOptionalItem
2608 where
2609 ___E: ::fidl_next::Encoder + ?Sized,
2610 DictionaryOptionalItem:
2611 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>,
2612 {
2613 #[inline]
2614 fn encode_option(
2615 this: ::core::option::Option<Self>,
2616 encoder: &mut ___E,
2617 out: &mut ::core::mem::MaybeUninit<
2618 ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>,
2619 >,
2620 _: (),
2621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2622 if let Some(inner) = this {
2623 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2624 ::fidl_next::WireBox::encode_present(out);
2625 } else {
2626 ::fidl_next::WireBox::encode_absent(out);
2627 }
2628
2629 Ok(())
2630 }
2631 }
2632
2633 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
2634 for DictionaryOptionalItem
2635 {
2636 #[inline]
2637 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
2638 Self {
2639 key: ::fidl_next::FromWire::from_wire(wire.key),
2640
2641 value: ::fidl_next::FromWire::from_wire(wire.value),
2642 }
2643 }
2644 }
2645
2646 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2647 pub struct DictionaryEnumerateIteratorGetNextResponse {
2648 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
2649
2650 pub end_id: u64,
2651 }
2652
2653 unsafe impl<___E>
2654 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
2655 for DictionaryEnumerateIteratorGetNextResponse
2656 where
2657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2658 ___E: ::fidl_next::Encoder,
2659 ___E: ::fidl_next::fuchsia::HandleEncoder,
2660 {
2661 #[inline]
2662 fn encode(
2663 self,
2664 encoder_: &mut ___E,
2665 out_: &mut ::core::mem::MaybeUninit<
2666 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2667 >,
2668 _: (),
2669 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2670 ::fidl_next::munge! {
2671 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
2672 items,
2673 end_id,
2674
2675 } = out_;
2676 }
2677
2678 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2679
2680 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2681 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2682
2683 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2684
2685 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2686
2687 Ok(())
2688 }
2689 }
2690
2691 unsafe impl<___E>
2692 ::fidl_next::EncodeOption<
2693 ::fidl_next::WireBox<
2694 'static,
2695 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2696 >,
2697 ___E,
2698 > for DictionaryEnumerateIteratorGetNextResponse
2699 where
2700 ___E: ::fidl_next::Encoder + ?Sized,
2701 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<
2702 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2703 ___E,
2704 >,
2705 {
2706 #[inline]
2707 fn encode_option(
2708 this: ::core::option::Option<Self>,
2709 encoder: &mut ___E,
2710 out: &mut ::core::mem::MaybeUninit<
2711 ::fidl_next::WireBox<
2712 'static,
2713 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2714 >,
2715 >,
2716 _: (),
2717 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2718 if let Some(inner) = this {
2719 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2720 ::fidl_next::WireBox::encode_present(out);
2721 } else {
2722 ::fidl_next::WireBox::encode_absent(out);
2723 }
2724
2725 Ok(())
2726 }
2727 }
2728
2729 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
2730 for DictionaryEnumerateIteratorGetNextResponse
2731 {
2732 #[inline]
2733 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
2734 Self {
2735 items: ::fidl_next::FromWire::from_wire(wire.items),
2736
2737 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2738 }
2739 }
2740 }
2741
2742 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2743 pub struct DictionaryKeysIteratorGetNextResponse {
2744 pub keys: ::std::vec::Vec<::std::string::String>,
2745 }
2746
2747 unsafe impl<___E>
2748 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
2749 for DictionaryKeysIteratorGetNextResponse
2750 where
2751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2752 ___E: ::fidl_next::Encoder,
2753 ___E: ::fidl_next::fuchsia::HandleEncoder,
2754 {
2755 #[inline]
2756 fn encode(
2757 self,
2758 encoder_: &mut ___E,
2759 out_: &mut ::core::mem::MaybeUninit<
2760 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2761 >,
2762 _: (),
2763 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2764 ::fidl_next::munge! {
2765 let crate::wire::DictionaryKeysIteratorGetNextResponse {
2766 keys,
2767
2768 } = out_;
2769 }
2770
2771 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
2772
2773 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
2774 ::fidl_next::Constrained::validate(_field, (128, 255))?;
2775
2776 Ok(())
2777 }
2778 }
2779
2780 unsafe impl<___E>
2781 ::fidl_next::EncodeOption<
2782 ::fidl_next::WireBox<
2783 'static,
2784 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2785 >,
2786 ___E,
2787 > for DictionaryKeysIteratorGetNextResponse
2788 where
2789 ___E: ::fidl_next::Encoder + ?Sized,
2790 DictionaryKeysIteratorGetNextResponse:
2791 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>,
2792 {
2793 #[inline]
2794 fn encode_option(
2795 this: ::core::option::Option<Self>,
2796 encoder: &mut ___E,
2797 out: &mut ::core::mem::MaybeUninit<
2798 ::fidl_next::WireBox<
2799 'static,
2800 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2801 >,
2802 >,
2803 _: (),
2804 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2805 if let Some(inner) = this {
2806 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2807 ::fidl_next::WireBox::encode_present(out);
2808 } else {
2809 ::fidl_next::WireBox::encode_absent(out);
2810 }
2811
2812 Ok(())
2813 }
2814 }
2815
2816 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
2817 for DictionaryKeysIteratorGetNextResponse
2818 {
2819 #[inline]
2820 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
2821 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
2822 }
2823 }
2824
2825 #[derive(Debug, PartialEq)]
2826 pub enum DictionaryRouterRouteResponse {
2827 Dictionary(crate::natural::DictionaryRef),
2828
2829 Unavailable(crate::natural::Unit),
2830 }
2831
2832 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>
2833 for DictionaryRouterRouteResponse
2834 where
2835 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2836 ___E: ::fidl_next::fuchsia::HandleEncoder,
2837 {
2838 #[inline]
2839 fn encode(
2840 self,
2841 encoder: &mut ___E,
2842 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRouterRouteResponse>,
2843 _: (),
2844 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2845 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
2846
2847 match self {
2848 Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2849 ___E,
2850 crate::wire::DictionaryRef,
2851 >(value, 1, encoder, raw, ())?,
2852
2853 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2854 ___E,
2855 crate::wire::Unit,
2856 >(value, 2, encoder, raw, ())?,
2857 }
2858
2859 Ok(())
2860 }
2861 }
2862
2863 unsafe impl<___E>
2864 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryRouterRouteResponse, ___E>
2865 for DictionaryRouterRouteResponse
2866 where
2867 ___E: ?Sized,
2868 DictionaryRouterRouteResponse:
2869 ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>,
2870 {
2871 #[inline]
2872 fn encode_option(
2873 this: ::core::option::Option<Self>,
2874 encoder: &mut ___E,
2875 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryRouterRouteResponse>,
2876 _: (),
2877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2878 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2879
2880 if let Some(inner) = this {
2881 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2882 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2883 } else {
2884 ::fidl_next::RawWireUnion::encode_absent(raw);
2885 }
2886
2887 Ok(())
2888 }
2889 }
2890
2891 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
2892 for DictionaryRouterRouteResponse
2893 {
2894 #[inline]
2895 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
2896 let wire = ::core::mem::ManuallyDrop::new(wire);
2897 match wire.raw.ordinal() {
2898 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
2899 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
2900 })),
2901
2902 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2903 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2904 })),
2905
2906 _ => unsafe { ::core::hint::unreachable_unchecked() },
2907 }
2908 }
2909 }
2910
2911 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2912 for DictionaryRouterRouteResponse
2913 {
2914 #[inline]
2915 fn from_wire_option(
2916 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2917 ) -> ::core::option::Option<Self> {
2918 if let Some(inner) = wire.into_option() {
2919 Some(::fidl_next::FromWire::from_wire(inner))
2920 } else {
2921 None
2922 }
2923 }
2924 }
2925
2926 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2927 for Box<DictionaryRouterRouteResponse>
2928 {
2929 #[inline]
2930 fn from_wire_option(
2931 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2932 ) -> ::core::option::Option<Self> {
2933 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
2934 crate::wire_optional::DictionaryRouterRouteResponse,
2935 >>::from_wire_option(wire)
2936 .map(Box::new)
2937 }
2938 }
2939
2940 #[derive(Debug, PartialEq)]
2941 pub enum DirConnectorRouterRouteResponse {
2942 DirConnector(crate::natural::DirConnector),
2943
2944 Unavailable(crate::natural::Unit),
2945 }
2946
2947 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>
2948 for DirConnectorRouterRouteResponse
2949 where
2950 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2951 ___E: ::fidl_next::fuchsia::HandleEncoder,
2952 {
2953 #[inline]
2954 fn encode(
2955 self,
2956 encoder: &mut ___E,
2957 out: &mut ::core::mem::MaybeUninit<crate::wire::DirConnectorRouterRouteResponse>,
2958 _: (),
2959 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2960 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2961
2962 match self {
2963 Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2964 ___E,
2965 crate::wire::DirConnector,
2966 >(value, 1, encoder, raw, ())?,
2967
2968 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
2969 ___E,
2970 crate::wire::Unit,
2971 >(value, 2, encoder, raw, ())?,
2972 }
2973
2974 Ok(())
2975 }
2976 }
2977
2978 unsafe impl<___E>
2979 ::fidl_next::EncodeOption<crate::wire_optional::DirConnectorRouterRouteResponse, ___E>
2980 for DirConnectorRouterRouteResponse
2981 where
2982 ___E: ?Sized,
2983 DirConnectorRouterRouteResponse:
2984 ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>,
2985 {
2986 #[inline]
2987 fn encode_option(
2988 this: ::core::option::Option<Self>,
2989 encoder: &mut ___E,
2990 out: &mut ::core::mem::MaybeUninit<
2991 crate::wire_optional::DirConnectorRouterRouteResponse,
2992 >,
2993 _: (),
2994 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2995 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2996
2997 if let Some(inner) = this {
2998 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2999 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3000 } else {
3001 ::fidl_next::RawWireUnion::encode_absent(raw);
3002 }
3003
3004 Ok(())
3005 }
3006 }
3007
3008 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
3009 for DirConnectorRouterRouteResponse
3010 {
3011 #[inline]
3012 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
3013 let wire = ::core::mem::ManuallyDrop::new(wire);
3014 match wire.raw.ordinal() {
3015 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
3016 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
3017 })),
3018
3019 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3020 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3021 })),
3022
3023 _ => unsafe { ::core::hint::unreachable_unchecked() },
3024 }
3025 }
3026 }
3027
3028 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3029 for DirConnectorRouterRouteResponse
3030 {
3031 #[inline]
3032 fn from_wire_option(
3033 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3034 ) -> ::core::option::Option<Self> {
3035 if let Some(inner) = wire.into_option() {
3036 Some(::fidl_next::FromWire::from_wire(inner))
3037 } else {
3038 None
3039 }
3040 }
3041 }
3042
3043 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3044 for Box<DirConnectorRouterRouteResponse>
3045 {
3046 #[inline]
3047 fn from_wire_option(
3048 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3049 ) -> ::core::option::Option<Self> {
3050 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
3051 crate::wire_optional::DirConnectorRouterRouteResponse,
3052 >>::from_wire_option(wire)
3053 .map(Box::new)
3054 }
3055 }
3056
3057 #[derive(Debug, PartialEq)]
3058 pub enum DirEntryRouterRouteResponse {
3059 DirEntry(crate::natural::DirEntry),
3060
3061 Unavailable(crate::natural::Unit),
3062 }
3063
3064 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>
3065 for DirEntryRouterRouteResponse
3066 where
3067 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3068 ___E: ::fidl_next::fuchsia::HandleEncoder,
3069 {
3070 #[inline]
3071 fn encode(
3072 self,
3073 encoder: &mut ___E,
3074 out: &mut ::core::mem::MaybeUninit<crate::wire::DirEntryRouterRouteResponse>,
3075 _: (),
3076 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3077 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
3078
3079 match self {
3080 Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
3081 ___E,
3082 crate::wire::DirEntry,
3083 >(value, 1, encoder, raw, ())?,
3084
3085 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
3086 ___E,
3087 crate::wire::Unit,
3088 >(value, 2, encoder, raw, ())?,
3089 }
3090
3091 Ok(())
3092 }
3093 }
3094
3095 unsafe impl<___E>
3096 ::fidl_next::EncodeOption<crate::wire_optional::DirEntryRouterRouteResponse, ___E>
3097 for DirEntryRouterRouteResponse
3098 where
3099 ___E: ?Sized,
3100 DirEntryRouterRouteResponse:
3101 ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>,
3102 {
3103 #[inline]
3104 fn encode_option(
3105 this: ::core::option::Option<Self>,
3106 encoder: &mut ___E,
3107 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirEntryRouterRouteResponse>,
3108 _: (),
3109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3110 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3111
3112 if let Some(inner) = this {
3113 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3114 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3115 } else {
3116 ::fidl_next::RawWireUnion::encode_absent(raw);
3117 }
3118
3119 Ok(())
3120 }
3121 }
3122
3123 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
3124 for DirEntryRouterRouteResponse
3125 {
3126 #[inline]
3127 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
3128 let wire = ::core::mem::ManuallyDrop::new(wire);
3129 match wire.raw.ordinal() {
3130 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
3131 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
3132 })),
3133
3134 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3135 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3136 })),
3137
3138 _ => unsafe { ::core::hint::unreachable_unchecked() },
3139 }
3140 }
3141 }
3142
3143 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3144 for DirEntryRouterRouteResponse
3145 {
3146 #[inline]
3147 fn from_wire_option(
3148 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3149 ) -> ::core::option::Option<Self> {
3150 if let Some(inner) = wire.into_option() {
3151 Some(::fidl_next::FromWire::from_wire(inner))
3152 } else {
3153 None
3154 }
3155 }
3156 }
3157
3158 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3159 for Box<DirEntryRouterRouteResponse>
3160 {
3161 #[inline]
3162 fn from_wire_option(
3163 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3164 ) -> ::core::option::Option<Self> {
3165 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
3166 crate::wire_optional::DirEntryRouterRouteResponse,
3167 >>::from_wire_option(wire)
3168 .map(Box::new)
3169 }
3170 }
3171
3172 #[derive(Debug, Default, PartialEq)]
3173 pub struct DirReceiverReceiveRequest {
3174 pub channel: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
3175
3176 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
3177
3178 pub subdir: ::core::option::Option<::std::string::String>,
3179 }
3180
3181 impl DirReceiverReceiveRequest {
3182 fn __max_ordinal(&self) -> usize {
3183 if self.subdir.is_some() {
3184 return 3;
3185 }
3186
3187 if self.flags.is_some() {
3188 return 2;
3189 }
3190
3191 if self.channel.is_some() {
3192 return 1;
3193 }
3194
3195 0
3196 }
3197 }
3198
3199 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest<'static>, ___E>
3200 for DirReceiverReceiveRequest
3201 where
3202 ___E: ::fidl_next::Encoder + ?Sized,
3203 ___E: ::fidl_next::fuchsia::HandleEncoder,
3204 {
3205 #[inline]
3206 fn encode(
3207 mut self,
3208 encoder: &mut ___E,
3209 out: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest<'static>>,
3210 _: (),
3211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3212 ::fidl_next::munge!(let crate::wire::DirReceiverReceiveRequest { table } = out);
3213
3214 let max_ord = self.__max_ordinal();
3215
3216 let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
3217 ::fidl_next::Wire::zero_padding(&mut out);
3218
3219 let mut preallocated =
3220 ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
3221
3222 for i in 1..=max_ord {
3223 match i {
3224 3 => {
3225 if let Some(value) = self.subdir.take() {
3226 ::fidl_next::WireEnvelope::encode_value::<
3227 ::fidl_next::WireString<'static>,
3228 ___E,
3229 >(
3230 value, preallocated.encoder, &mut out, 4095
3231 )?;
3232 } else {
3233 ::fidl_next::WireEnvelope::encode_zero(&mut out)
3234 }
3235 }
3236
3237 2 => {
3238 if let Some(value) = self.flags.take() {
3239 ::fidl_next::WireEnvelope::encode_value::<
3240 ::fidl_next_fuchsia_io::wire::Flags,
3241 ___E,
3242 >(
3243 value, preallocated.encoder, &mut out, ()
3244 )?;
3245 } else {
3246 ::fidl_next::WireEnvelope::encode_zero(&mut out)
3247 }
3248 }
3249
3250 1 => {
3251 if let Some(value) = self.channel.take() {
3252 ::fidl_next::WireEnvelope::encode_value::<
3253 ::fidl_next::fuchsia::WireChannel,
3254 ___E,
3255 >(
3256 value, preallocated.encoder, &mut out, ()
3257 )?;
3258 } else {
3259 ::fidl_next::WireEnvelope::encode_zero(&mut out)
3260 }
3261 }
3262
3263 _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
3264 }
3265 unsafe {
3266 preallocated.write_next(out.assume_init_ref());
3267 }
3268 }
3269
3270 ::fidl_next::WireTable::encode_len(table, max_ord);
3271
3272 Ok(())
3273 }
3274 }
3275
3276 impl<'de> ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest<'de>>
3277 for DirReceiverReceiveRequest
3278 {
3279 #[inline]
3280 fn from_wire(wire_: crate::wire::DirReceiverReceiveRequest<'de>) -> Self {
3281 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
3282
3283 let channel = wire_.table.get(1);
3284
3285 let flags = wire_.table.get(2);
3286
3287 let subdir = wire_.table.get(3);
3288
3289 Self {
3290 channel: channel.map(|envelope| {
3291 ::fidl_next::FromWire::from_wire(unsafe {
3292 envelope.read_unchecked::<::fidl_next::fuchsia::WireChannel>()
3293 })
3294 }),
3295
3296 flags: flags.map(|envelope| {
3297 ::fidl_next::FromWire::from_wire(unsafe {
3298 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
3299 })
3300 }),
3301
3302 subdir: subdir.map(|envelope| {
3303 ::fidl_next::FromWire::from_wire(unsafe {
3304 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
3305 })
3306 }),
3307 }
3308 }
3309 }
3310
3311 #[derive(Debug, PartialEq)]
3312 pub enum DirectoryRouterRouteResponse {
3313 Directory(
3314 ::fidl_next::ClientEnd<
3315 ::fidl_next_fuchsia_io::Directory,
3316 ::fidl_next::fuchsia::zx::Channel,
3317 >,
3318 ),
3319
3320 Unavailable(crate::natural::Unit),
3321 }
3322
3323 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>
3324 for DirectoryRouterRouteResponse
3325 where
3326 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3327 ___E: ::fidl_next::fuchsia::HandleEncoder,
3328 {
3329 #[inline]
3330 fn encode(
3331 self,
3332 encoder: &mut ___E,
3333 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRouterRouteResponse>,
3334 _: (),
3335 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3336 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
3337
3338 match self {
3339 Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
3340 ___E,
3341 ::fidl_next::ClientEnd<
3342 ::fidl_next_fuchsia_io::Directory,
3343 ::fidl_next::fuchsia::WireChannel,
3344 >,
3345 >(value, 1, encoder, raw, ())?,
3346
3347 Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
3348 ___E,
3349 crate::wire::Unit,
3350 >(value, 2, encoder, raw, ())?,
3351 }
3352
3353 Ok(())
3354 }
3355 }
3356
3357 unsafe impl<___E>
3358 ::fidl_next::EncodeOption<crate::wire_optional::DirectoryRouterRouteResponse, ___E>
3359 for DirectoryRouterRouteResponse
3360 where
3361 ___E: ?Sized,
3362 DirectoryRouterRouteResponse:
3363 ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>,
3364 {
3365 #[inline]
3366 fn encode_option(
3367 this: ::core::option::Option<Self>,
3368 encoder: &mut ___E,
3369 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirectoryRouterRouteResponse>,
3370 _: (),
3371 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3372 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3373
3374 if let Some(inner) = this {
3375 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3376 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3377 } else {
3378 ::fidl_next::RawWireUnion::encode_absent(raw);
3379 }
3380
3381 Ok(())
3382 }
3383 }
3384
3385 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
3386 for DirectoryRouterRouteResponse
3387 {
3388 #[inline]
3389 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
3390 let wire = ::core::mem::ManuallyDrop::new(wire);
3391 match wire.raw.ordinal() {
3392 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
3393 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3394 ::fidl_next_fuchsia_io::Directory,
3395 ::fidl_next::fuchsia::WireChannel,
3396 >>()
3397 })),
3398
3399 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3400 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3401 })),
3402
3403 _ => unsafe { ::core::hint::unreachable_unchecked() },
3404 }
3405 }
3406 }
3407
3408 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3409 for DirectoryRouterRouteResponse
3410 {
3411 #[inline]
3412 fn from_wire_option(
3413 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3414 ) -> ::core::option::Option<Self> {
3415 if let Some(inner) = wire.into_option() {
3416 Some(::fidl_next::FromWire::from_wire(inner))
3417 } else {
3418 None
3419 }
3420 }
3421 }
3422
3423 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3424 for Box<DirectoryRouterRouteResponse>
3425 {
3426 #[inline]
3427 fn from_wire_option(
3428 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3429 ) -> ::core::option::Option<Self> {
3430 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
3431 crate::wire_optional::DirectoryRouterRouteResponse,
3432 >>::from_wire_option(wire)
3433 .map(Box::new)
3434 }
3435 }
3436
3437 #[doc = " Contains a protocol open request.\n"]
3438 #[derive(Debug, PartialEq)]
3439 #[repr(C)]
3440 pub struct ProtocolPayload {
3441 pub channel: ::fidl_next::fuchsia::zx::Channel,
3442 }
3443
3444 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E> for ProtocolPayload
3445 where
3446 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3447 ___E: ::fidl_next::fuchsia::HandleEncoder,
3448 {
3449 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
3450 ::fidl_next::CopyOptimization::enable_if(
3451 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
3452 ::fidl_next::fuchsia::WireChannel,
3453 ___E,
3454 >>::COPY_OPTIMIZATION
3455 .is_enabled(),
3456 )
3457 };
3458
3459 #[inline]
3460 fn encode(
3461 self,
3462 encoder_: &mut ___E,
3463 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
3464 _: (),
3465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3466 ::fidl_next::munge! {
3467 let crate::wire::ProtocolPayload {
3468 channel,
3469
3470 } = out_;
3471 }
3472
3473 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3474
3475 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3476
3477 Ok(())
3478 }
3479 }
3480
3481 unsafe impl<___E>
3482 ::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>, ___E>
3483 for ProtocolPayload
3484 where
3485 ___E: ::fidl_next::Encoder + ?Sized,
3486 ProtocolPayload: ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>,
3487 {
3488 #[inline]
3489 fn encode_option(
3490 this: ::core::option::Option<Self>,
3491 encoder: &mut ___E,
3492 out: &mut ::core::mem::MaybeUninit<
3493 ::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>,
3494 >,
3495 _: (),
3496 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3497 if let Some(inner) = this {
3498 ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3499 ::fidl_next::WireBox::encode_present(out);
3500 } else {
3501 ::fidl_next::WireBox::encode_absent(out);
3502 }
3503
3504 Ok(())
3505 }
3506 }
3507
3508 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
3509 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
3510 ::fidl_next::CopyOptimization::enable_if(
3511 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3512 ::fidl_next::fuchsia::WireChannel,
3513 >>::COPY_OPTIMIZATION
3514 .is_enabled(),
3515 )
3516 };
3517
3518 #[inline]
3519 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
3520 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
3521 }
3522 }
3523}
3524
3525pub mod wire {
3526
3527 pub use fidl_next_common_fuchsia_component_sandbox::wire::*;
3528
3529 pub type Token = ::fidl_next::fuchsia::WireEventPair;
3531
3532 #[derive(Debug)]
3534 #[repr(C)]
3535 pub struct DirConnector {
3536 pub token: ::fidl_next::fuchsia::WireEventPair,
3537 }
3538
3539 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
3540 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
3541
3542 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
3543
3544 unsafe impl ::fidl_next::Wire for DirConnector {
3545 type Owned<'de> = DirConnector;
3546
3547 #[inline]
3548 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3549 ::fidl_next::munge! {
3550 let Self {
3551
3552 token,
3553
3554 } = &mut *out_;
3555 }
3556
3557 ::fidl_next::Wire::zero_padding(token);
3558 }
3559 }
3560
3561 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
3562 where
3563 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3564 ___D: ::fidl_next::fuchsia::HandleDecoder,
3565 {
3566 fn decode(
3567 slot_: ::fidl_next::Slot<'_, Self>,
3568 decoder_: &mut ___D,
3569 _: (),
3570 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3571 ::fidl_next::munge! {
3572 let Self {
3573
3574 mut token,
3575
3576 } = slot_;
3577 }
3578
3579 let _field = token.as_mut();
3580
3581 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3582
3583 Ok(())
3584 }
3585 }
3586
3587 impl ::fidl_next::IntoNatural for DirConnector {
3588 type Natural = crate::natural::DirConnector;
3589 }
3590
3591 impl ::fidl_next::Unconstrained for DirConnector {}
3592
3593 #[repr(C)]
3595 pub struct AggregateSource<'de> {
3596 pub(crate) table: ::fidl_next::WireTable<'de>,
3597 }
3598
3599 impl<'de> Drop for AggregateSource<'de> {
3600 fn drop(&mut self) {
3601 let _ = self
3602 .table
3603 .get(1)
3604 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DirConnector>() });
3605
3606 let _ = self.table.get(2)
3607 .map(|envelope| unsafe {
3608 envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>()
3609 });
3610
3611 let _ = self.table.get(3).map(|envelope| unsafe {
3612 envelope.read_unchecked::<::fidl_next::WireVector<
3613 'de,
3614 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3615 >>()
3616 });
3617 }
3618 }
3619
3620 unsafe impl ::fidl_next::Wire for AggregateSource<'static> {
3621 type Owned<'de> = AggregateSource<'de>;
3622
3623 #[inline]
3624 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3625 ::fidl_next::munge!(let Self { table } = out);
3626 ::fidl_next::WireTable::zero_padding(table);
3627 }
3628 }
3629
3630 unsafe impl<___D> ::fidl_next::Decode<___D> for AggregateSource<'static>
3631 where
3632 ___D: ::fidl_next::Decoder + ?Sized,
3633 ___D: ::fidl_next::fuchsia::HandleDecoder,
3634 {
3635 fn decode(
3636 slot: ::fidl_next::Slot<'_, Self>,
3637 decoder: &mut ___D,
3638 _: (),
3639 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3640 ::fidl_next::munge!(let Self { table } = slot);
3641
3642 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3643 match ordinal {
3644 0 => unsafe { ::core::hint::unreachable_unchecked() },
3645
3646 1 => {
3647 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DirConnector>(
3648 slot.as_mut(),
3649 decoder,
3650 (),
3651 )?;
3652
3653 Ok(())
3654 }
3655
3656 2 => {
3657 ::fidl_next::WireEnvelope::decode_as::<
3658 ___D,
3659 ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
3660 >(slot.as_mut(), decoder, (4294967295, 255))?;
3661
3662 Ok(())
3663 }
3664
3665 3 => {
3666 ::fidl_next::WireEnvelope::decode_as::<
3667 ___D,
3668 ::fidl_next::WireVector<
3669 'static,
3670 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'static>,
3671 >,
3672 >(slot.as_mut(), decoder, (4294967295, ()))?;
3673
3674 Ok(())
3675 }
3676
3677 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
3678 }
3679 })
3680 }
3681 }
3682
3683 impl<'de> AggregateSource<'de> {
3684 pub fn dir_connector(&self) -> ::core::option::Option<&crate::wire::DirConnector> {
3685 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3686 }
3687
3688 pub fn source_instance_filter(
3689 &self,
3690 ) -> ::core::option::Option<&::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>>
3691 {
3692 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3693 }
3694
3695 pub fn renamed_instances(
3696 &self,
3697 ) -> ::core::option::Option<
3698 &::fidl_next::WireVector<
3699 'de,
3700 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3701 >,
3702 > {
3703 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3704 }
3705 }
3706
3707 impl<'de> ::core::fmt::Debug for AggregateSource<'de> {
3708 fn fmt(
3709 &self,
3710 f: &mut ::core::fmt::Formatter<'_>,
3711 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3712 f.debug_struct("AggregateSource")
3713 .field("dir_connector", &self.dir_connector())
3714 .field("source_instance_filter", &self.source_instance_filter())
3715 .field("renamed_instances", &self.renamed_instances())
3716 .finish()
3717 }
3718 }
3719
3720 impl<'de> ::fidl_next::IntoNatural for AggregateSource<'de> {
3721 type Natural = crate::natural::AggregateSource;
3722 }
3723
3724 impl ::fidl_next::Unconstrained for AggregateSource<'_> {}
3725
3726 #[derive(Debug)]
3728 #[repr(C)]
3729 pub struct DictionaryRef {
3730 pub token: ::fidl_next::fuchsia::WireEventPair,
3731 }
3732
3733 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
3734 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
3735
3736 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
3737
3738 unsafe impl ::fidl_next::Wire for DictionaryRef {
3739 type Owned<'de> = DictionaryRef;
3740
3741 #[inline]
3742 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3743 ::fidl_next::munge! {
3744 let Self {
3745
3746 token,
3747
3748 } = &mut *out_;
3749 }
3750
3751 ::fidl_next::Wire::zero_padding(token);
3752 }
3753 }
3754
3755 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
3756 where
3757 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3758 ___D: ::fidl_next::fuchsia::HandleDecoder,
3759 {
3760 fn decode(
3761 slot_: ::fidl_next::Slot<'_, Self>,
3762 decoder_: &mut ___D,
3763 _: (),
3764 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3765 ::fidl_next::munge! {
3766 let Self {
3767
3768 mut token,
3769
3770 } = slot_;
3771 }
3772
3773 let _field = token.as_mut();
3774
3775 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3776
3777 Ok(())
3778 }
3779 }
3780
3781 impl ::fidl_next::IntoNatural for DictionaryRef {
3782 type Natural = crate::natural::DictionaryRef;
3783 }
3784
3785 impl ::fidl_next::Unconstrained for DictionaryRef {}
3786
3787 #[derive(Debug)]
3789 #[repr(C)]
3790 pub struct Connector {
3791 pub token: ::fidl_next::fuchsia::WireEventPair,
3792 }
3793
3794 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
3795 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
3796
3797 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
3798
3799 unsafe impl ::fidl_next::Wire for Connector {
3800 type Owned<'de> = Connector;
3801
3802 #[inline]
3803 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3804 ::fidl_next::munge! {
3805 let Self {
3806
3807 token,
3808
3809 } = &mut *out_;
3810 }
3811
3812 ::fidl_next::Wire::zero_padding(token);
3813 }
3814 }
3815
3816 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
3817 where
3818 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3819 ___D: ::fidl_next::fuchsia::HandleDecoder,
3820 {
3821 fn decode(
3822 slot_: ::fidl_next::Slot<'_, Self>,
3823 decoder_: &mut ___D,
3824 _: (),
3825 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3826 ::fidl_next::munge! {
3827 let Self {
3828
3829 mut token,
3830
3831 } = slot_;
3832 }
3833
3834 let _field = token.as_mut();
3835
3836 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3837
3838 Ok(())
3839 }
3840 }
3841
3842 impl ::fidl_next::IntoNatural for Connector {
3843 type Natural = crate::natural::Connector;
3844 }
3845
3846 impl ::fidl_next::Unconstrained for Connector {}
3847
3848 #[derive(Debug)]
3850 #[repr(C)]
3851 pub struct DirEntry {
3852 pub token: ::fidl_next::fuchsia::WireEventPair,
3853 }
3854
3855 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
3856 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
3857
3858 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
3859
3860 unsafe impl ::fidl_next::Wire for DirEntry {
3861 type Owned<'de> = DirEntry;
3862
3863 #[inline]
3864 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3865 ::fidl_next::munge! {
3866 let Self {
3867
3868 token,
3869
3870 } = &mut *out_;
3871 }
3872
3873 ::fidl_next::Wire::zero_padding(token);
3874 }
3875 }
3876
3877 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
3878 where
3879 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3880 ___D: ::fidl_next::fuchsia::HandleDecoder,
3881 {
3882 fn decode(
3883 slot_: ::fidl_next::Slot<'_, Self>,
3884 decoder_: &mut ___D,
3885 _: (),
3886 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3887 ::fidl_next::munge! {
3888 let Self {
3889
3890 mut token,
3891
3892 } = slot_;
3893 }
3894
3895 let _field = token.as_mut();
3896
3897 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3898
3899 Ok(())
3900 }
3901 }
3902
3903 impl ::fidl_next::IntoNatural for DirEntry {
3904 type Natural = crate::natural::DirEntry;
3905 }
3906
3907 impl ::fidl_next::Unconstrained for DirEntry {}
3908
3909 #[repr(transparent)]
3911 pub struct Capability<'de> {
3912 pub(crate) raw: ::fidl_next::RawWireUnion,
3913 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3914 }
3915
3916 impl<'de> Drop for Capability<'de> {
3917 fn drop(&mut self) {
3918 match self.raw.ordinal() {
3919 1 => {
3920 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
3921 }
3922
3923 2 => {
3924 let _ = unsafe {
3925 self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
3926 };
3927 }
3928
3929 3 => {
3930 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
3931 }
3932
3933 4 => {
3934 let _ =
3935 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
3936 }
3937
3938 5 => {
3939 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
3940 }
3941
3942 6 => {
3943 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
3944 }
3945
3946 7 => {
3947 let _ = unsafe {
3948 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3949 ::fidl_next_fuchsia_io::Directory,
3950 ::fidl_next::fuchsia::WireChannel,
3951 >>()
3952 };
3953 }
3954
3955 8 => {
3956 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
3957 }
3958
3959 9 => {
3960 let _ = unsafe {
3961 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3962 crate::ConnectorRouter,
3963 ::fidl_next::fuchsia::WireChannel,
3964 >>()
3965 };
3966 }
3967
3968 10 => {
3969 let _ = unsafe {
3970 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3971 crate::DictionaryRouter,
3972 ::fidl_next::fuchsia::WireChannel,
3973 >>()
3974 };
3975 }
3976
3977 11 => {
3978 let _ = unsafe {
3979 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3980 crate::DirEntryRouter,
3981 ::fidl_next::fuchsia::WireChannel,
3982 >>()
3983 };
3984 }
3985
3986 12 => {
3987 let _ = unsafe {
3988 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3989 crate::DataRouter,
3990 ::fidl_next::fuchsia::WireChannel,
3991 >>()
3992 };
3993 }
3994
3995 13 => {
3996 let _ = unsafe {
3997 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3998 crate::DirConnectorRouter,
3999 ::fidl_next::fuchsia::WireChannel,
4000 >>()
4001 };
4002 }
4003
4004 _ => (),
4005 }
4006 }
4007 }
4008
4009 unsafe impl ::fidl_next::Wire for Capability<'static> {
4010 type Owned<'de> = Capability<'de>;
4011
4012 #[inline]
4013 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4014 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4015 ::fidl_next::RawWireUnion::zero_padding(raw);
4016 }
4017 }
4018
4019 pub mod capability {
4020 pub enum Ref<'de> {
4021 Unit(&'de crate::wire::Unit),
4022
4023 Handle(&'de ::fidl_next::fuchsia::WireNullableHandle),
4024
4025 Data(&'de crate::wire::Data<'de>),
4026
4027 Dictionary(&'de crate::wire::DictionaryRef),
4028
4029 Connector(&'de crate::wire::Connector),
4030
4031 DirConnector(&'de crate::wire::DirConnector),
4032
4033 Directory(
4034 &'de ::fidl_next::ClientEnd<
4035 ::fidl_next_fuchsia_io::Directory,
4036 ::fidl_next::fuchsia::WireChannel,
4037 >,
4038 ),
4039
4040 DirEntry(&'de crate::wire::DirEntry),
4041
4042 ConnectorRouter(
4043 &'de ::fidl_next::ClientEnd<
4044 crate::ConnectorRouter,
4045 ::fidl_next::fuchsia::WireChannel,
4046 >,
4047 ),
4048
4049 DictionaryRouter(
4050 &'de ::fidl_next::ClientEnd<
4051 crate::DictionaryRouter,
4052 ::fidl_next::fuchsia::WireChannel,
4053 >,
4054 ),
4055
4056 DirEntryRouter(
4057 &'de ::fidl_next::ClientEnd<
4058 crate::DirEntryRouter,
4059 ::fidl_next::fuchsia::WireChannel,
4060 >,
4061 ),
4062
4063 DataRouter(
4064 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
4065 ),
4066
4067 DirConnectorRouter(
4068 &'de ::fidl_next::ClientEnd<
4069 crate::DirConnectorRouter,
4070 ::fidl_next::fuchsia::WireChannel,
4071 >,
4072 ),
4073
4074 UnknownOrdinal_(u64),
4075 }
4076 }
4077
4078 impl<'de> Capability<'de> {
4079 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
4080 match self.raw.ordinal() {
4081 1 => crate::wire::capability::Ref::Unit(unsafe {
4082 self.raw.get().deref_unchecked::<crate::wire::Unit>()
4083 }),
4084
4085 2 => crate::wire::capability::Ref::Handle(unsafe {
4086 self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
4087 }),
4088
4089 3 => crate::wire::capability::Ref::Data(unsafe {
4090 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
4091 }),
4092
4093 4 => crate::wire::capability::Ref::Dictionary(unsafe {
4094 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
4095 }),
4096
4097 5 => crate::wire::capability::Ref::Connector(unsafe {
4098 self.raw.get().deref_unchecked::<crate::wire::Connector>()
4099 }),
4100
4101 6 => crate::wire::capability::Ref::DirConnector(unsafe {
4102 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
4103 }),
4104
4105 7 => crate::wire::capability::Ref::Directory(unsafe {
4106 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4107 ::fidl_next_fuchsia_io::Directory,
4108 ::fidl_next::fuchsia::WireChannel,
4109 >>()
4110 }),
4111
4112 8 => crate::wire::capability::Ref::DirEntry(unsafe {
4113 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
4114 }),
4115
4116 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
4117 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4118 crate::ConnectorRouter,
4119 ::fidl_next::fuchsia::WireChannel,
4120 >>()
4121 }),
4122
4123 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
4124 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4125 crate::DictionaryRouter,
4126 ::fidl_next::fuchsia::WireChannel,
4127 >>()
4128 }),
4129
4130 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
4131 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4132 crate::DirEntryRouter,
4133 ::fidl_next::fuchsia::WireChannel,
4134 >>()
4135 }),
4136
4137 12 => crate::wire::capability::Ref::DataRouter(unsafe {
4138 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
4139 }),
4140
4141 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
4142 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4143 crate::DirConnectorRouter,
4144 ::fidl_next::fuchsia::WireChannel,
4145 >>()
4146 }),
4147
4148 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
4149 }
4150 }
4151 }
4152
4153 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
4154 where
4155 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4156 ___D: ::fidl_next::Decoder,
4157 ___D: ::fidl_next::fuchsia::HandleDecoder,
4158 {
4159 fn decode(
4160 mut slot: ::fidl_next::Slot<'_, Self>,
4161 decoder: &mut ___D,
4162 _: (),
4163 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4164 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4165 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
4166 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
4167 raw,
4168 decoder,
4169 (),
4170 )?,
4171
4172 2 => ::fidl_next::RawWireUnion::decode_as::<
4173 ___D,
4174 ::fidl_next::fuchsia::WireNullableHandle,
4175 >(raw, decoder, ())?,
4176
4177 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
4178 raw,
4179 decoder,
4180 (),
4181 )?,
4182
4183 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
4184 raw,
4185 decoder,
4186 (),
4187 )?,
4188
4189 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
4190 raw,
4191 decoder,
4192 (),
4193 )?,
4194
4195 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
4196 raw,
4197 decoder,
4198 (),
4199 )?,
4200
4201 7 => ::fidl_next::RawWireUnion::decode_as::<
4202 ___D,
4203 ::fidl_next::ClientEnd<
4204 ::fidl_next_fuchsia_io::Directory,
4205 ::fidl_next::fuchsia::WireChannel,
4206 >,
4207 >(raw, decoder, ())?,
4208
4209 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
4210 raw,
4211 decoder,
4212 (),
4213 )?,
4214
4215 9 => ::fidl_next::RawWireUnion::decode_as::<
4216 ___D,
4217 ::fidl_next::ClientEnd<
4218 crate::ConnectorRouter,
4219 ::fidl_next::fuchsia::WireChannel,
4220 >,
4221 >(raw, decoder, ())?,
4222
4223 10 => ::fidl_next::RawWireUnion::decode_as::<
4224 ___D,
4225 ::fidl_next::ClientEnd<
4226 crate::DictionaryRouter,
4227 ::fidl_next::fuchsia::WireChannel,
4228 >,
4229 >(raw, decoder, ())?,
4230
4231 11 => ::fidl_next::RawWireUnion::decode_as::<
4232 ___D,
4233 ::fidl_next::ClientEnd<
4234 crate::DirEntryRouter,
4235 ::fidl_next::fuchsia::WireChannel,
4236 >,
4237 >(raw, decoder, ())?,
4238
4239 12 => ::fidl_next::RawWireUnion::decode_as::<
4240 ___D,
4241 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
4242 >(raw, decoder, ())?,
4243
4244 13 => ::fidl_next::RawWireUnion::decode_as::<
4245 ___D,
4246 ::fidl_next::ClientEnd<
4247 crate::DirConnectorRouter,
4248 ::fidl_next::fuchsia::WireChannel,
4249 >,
4250 >(raw, decoder, ())?,
4251
4252 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
4253 }
4254
4255 Ok(())
4256 }
4257 }
4258
4259 impl<'de> ::core::fmt::Debug for Capability<'de> {
4260 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4261 match self.raw.ordinal() {
4262 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
4263 2 => unsafe {
4264 self.raw
4265 .get()
4266 .deref_unchecked::<::fidl_next::fuchsia::WireNullableHandle>()
4267 .fmt(f)
4268 },
4269 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
4270 4 => unsafe {
4271 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
4272 },
4273 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
4274 6 => unsafe {
4275 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
4276 },
4277 7 => unsafe {
4278 self.raw
4279 .get()
4280 .deref_unchecked::<::fidl_next::ClientEnd<
4281 ::fidl_next_fuchsia_io::Directory,
4282 ::fidl_next::fuchsia::WireChannel,
4283 >>()
4284 .fmt(f)
4285 },
4286 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
4287 9 => unsafe {
4288 self.raw
4289 .get()
4290 .deref_unchecked::<::fidl_next::ClientEnd<
4291 crate::ConnectorRouter,
4292 ::fidl_next::fuchsia::WireChannel,
4293 >>()
4294 .fmt(f)
4295 },
4296 10 => unsafe {
4297 self.raw
4298 .get()
4299 .deref_unchecked::<::fidl_next::ClientEnd<
4300 crate::DictionaryRouter,
4301 ::fidl_next::fuchsia::WireChannel,
4302 >>()
4303 .fmt(f)
4304 },
4305 11 => unsafe {
4306 self.raw
4307 .get()
4308 .deref_unchecked::<::fidl_next::ClientEnd<
4309 crate::DirEntryRouter,
4310 ::fidl_next::fuchsia::WireChannel,
4311 >>()
4312 .fmt(f)
4313 },
4314 12 => unsafe {
4315 self.raw.get().deref_unchecked::<
4316 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
4317 >().fmt(f)
4318 },
4319 13 => unsafe {
4320 self.raw
4321 .get()
4322 .deref_unchecked::<::fidl_next::ClientEnd<
4323 crate::DirConnectorRouter,
4324 ::fidl_next::fuchsia::WireChannel,
4325 >>()
4326 .fmt(f)
4327 },
4328 _ => unsafe { ::core::hint::unreachable_unchecked() },
4329 }
4330 }
4331 }
4332
4333 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
4334 type Natural = crate::natural::Capability;
4335 }
4336
4337 impl ::fidl_next::Unconstrained for Capability<'static> {}
4338
4339 #[derive(Debug)]
4341 #[repr(C)]
4342 pub struct CapabilityStoreConnectorCreateRequest {
4343 pub id: ::fidl_next::WireU64,
4344
4345 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
4346 }
4347
4348 static_assertions::const_assert_eq!(
4349 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
4350 16
4351 );
4352 static_assertions::const_assert_eq!(
4353 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
4354 8
4355 );
4356
4357 static_assertions::const_assert_eq!(
4358 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
4359 0
4360 );
4361
4362 static_assertions::const_assert_eq!(
4363 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
4364 8
4365 );
4366
4367 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
4368 type Owned<'de> = CapabilityStoreConnectorCreateRequest;
4369
4370 #[inline]
4371 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4372 ::fidl_next::munge! {
4373 let Self {
4374
4375 id,
4376 receiver,
4377
4378 } = &mut *out_;
4379 }
4380
4381 ::fidl_next::Wire::zero_padding(id);
4382
4383 ::fidl_next::Wire::zero_padding(receiver);
4384
4385 unsafe {
4386 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4387 }
4388 }
4389 }
4390
4391 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
4392 where
4393 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4394 ___D: ::fidl_next::fuchsia::HandleDecoder,
4395 {
4396 fn decode(
4397 slot_: ::fidl_next::Slot<'_, Self>,
4398 decoder_: &mut ___D,
4399 _: (),
4400 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4401 if slot_.as_bytes()[12..16] != [0u8; 4] {
4402 return Err(::fidl_next::DecodeError::InvalidPadding);
4403 }
4404
4405 ::fidl_next::munge! {
4406 let Self {
4407
4408 mut id,
4409 mut receiver,
4410
4411 } = slot_;
4412 }
4413
4414 let _field = id.as_mut();
4415
4416 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4417
4418 let _field = receiver.as_mut();
4419
4420 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4421
4422 Ok(())
4423 }
4424 }
4425
4426 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
4427 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
4428 }
4429
4430 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateRequest {}
4431
4432 #[derive(Debug)]
4434 #[repr(C)]
4435 pub struct CapabilityStoreConnectorOpenRequest {
4436 pub id: ::fidl_next::WireU64,
4437
4438 pub server_end: ::fidl_next::fuchsia::WireChannel,
4439 }
4440
4441 static_assertions::const_assert_eq!(
4442 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
4443 16
4444 );
4445 static_assertions::const_assert_eq!(
4446 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
4447 8
4448 );
4449
4450 static_assertions::const_assert_eq!(
4451 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
4452 0
4453 );
4454
4455 static_assertions::const_assert_eq!(
4456 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
4457 8
4458 );
4459
4460 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
4461 type Owned<'de> = CapabilityStoreConnectorOpenRequest;
4462
4463 #[inline]
4464 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4465 ::fidl_next::munge! {
4466 let Self {
4467
4468 id,
4469 server_end,
4470
4471 } = &mut *out_;
4472 }
4473
4474 ::fidl_next::Wire::zero_padding(id);
4475
4476 ::fidl_next::Wire::zero_padding(server_end);
4477
4478 unsafe {
4479 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4480 }
4481 }
4482 }
4483
4484 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
4485 where
4486 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4487 ___D: ::fidl_next::fuchsia::HandleDecoder,
4488 {
4489 fn decode(
4490 slot_: ::fidl_next::Slot<'_, Self>,
4491 decoder_: &mut ___D,
4492 _: (),
4493 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4494 if slot_.as_bytes()[12..16] != [0u8; 4] {
4495 return Err(::fidl_next::DecodeError::InvalidPadding);
4496 }
4497
4498 ::fidl_next::munge! {
4499 let Self {
4500
4501 mut id,
4502 mut server_end,
4503
4504 } = slot_;
4505 }
4506
4507 let _field = id.as_mut();
4508
4509 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4510
4511 let _field = server_end.as_mut();
4512
4513 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4514
4515 Ok(())
4516 }
4517 }
4518
4519 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
4520 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
4521 }
4522
4523 impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenRequest {}
4524
4525 #[derive(Debug)]
4527 #[repr(C)]
4528 pub struct CapabilityStoreDirConnectorCreateRequest {
4529 pub id: ::fidl_next::WireU64,
4530
4531 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
4532 }
4533
4534 static_assertions::const_assert_eq!(
4535 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
4536 16
4537 );
4538 static_assertions::const_assert_eq!(
4539 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
4540 8
4541 );
4542
4543 static_assertions::const_assert_eq!(
4544 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
4545 0
4546 );
4547
4548 static_assertions::const_assert_eq!(
4549 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
4550 8
4551 );
4552
4553 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
4554 type Owned<'de> = CapabilityStoreDirConnectorCreateRequest;
4555
4556 #[inline]
4557 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4558 ::fidl_next::munge! {
4559 let Self {
4560
4561 id,
4562 receiver,
4563
4564 } = &mut *out_;
4565 }
4566
4567 ::fidl_next::Wire::zero_padding(id);
4568
4569 ::fidl_next::Wire::zero_padding(receiver);
4570
4571 unsafe {
4572 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4573 }
4574 }
4575 }
4576
4577 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
4578 where
4579 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4580 ___D: ::fidl_next::fuchsia::HandleDecoder,
4581 {
4582 fn decode(
4583 slot_: ::fidl_next::Slot<'_, Self>,
4584 decoder_: &mut ___D,
4585 _: (),
4586 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4587 if slot_.as_bytes()[12..16] != [0u8; 4] {
4588 return Err(::fidl_next::DecodeError::InvalidPadding);
4589 }
4590
4591 ::fidl_next::munge! {
4592 let Self {
4593
4594 mut id,
4595 mut receiver,
4596
4597 } = slot_;
4598 }
4599
4600 let _field = id.as_mut();
4601
4602 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4603
4604 let _field = receiver.as_mut();
4605
4606 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4607
4608 Ok(())
4609 }
4610 }
4611
4612 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
4613 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
4614 }
4615
4616 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateRequest {}
4617
4618 #[derive(Debug)]
4620 #[repr(C)]
4621 pub struct CapabilityStoreDictionaryLegacyImportRequest {
4622 pub id: ::fidl_next::WireU64,
4623
4624 pub client_end: ::fidl_next::fuchsia::WireChannel,
4625 }
4626
4627 static_assertions::const_assert_eq!(
4628 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4629 16
4630 );
4631 static_assertions::const_assert_eq!(
4632 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4633 8
4634 );
4635
4636 static_assertions::const_assert_eq!(
4637 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
4638 0
4639 );
4640
4641 static_assertions::const_assert_eq!(
4642 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
4643 8
4644 );
4645
4646 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
4647 type Owned<'de> = CapabilityStoreDictionaryLegacyImportRequest;
4648
4649 #[inline]
4650 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4651 ::fidl_next::munge! {
4652 let Self {
4653
4654 id,
4655 client_end,
4656
4657 } = &mut *out_;
4658 }
4659
4660 ::fidl_next::Wire::zero_padding(id);
4661
4662 ::fidl_next::Wire::zero_padding(client_end);
4663
4664 unsafe {
4665 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4666 }
4667 }
4668 }
4669
4670 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
4671 where
4672 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4673 ___D: ::fidl_next::fuchsia::HandleDecoder,
4674 {
4675 fn decode(
4676 slot_: ::fidl_next::Slot<'_, Self>,
4677 decoder_: &mut ___D,
4678 _: (),
4679 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4680 if slot_.as_bytes()[12..16] != [0u8; 4] {
4681 return Err(::fidl_next::DecodeError::InvalidPadding);
4682 }
4683
4684 ::fidl_next::munge! {
4685 let Self {
4686
4687 mut id,
4688 mut client_end,
4689
4690 } = slot_;
4691 }
4692
4693 let _field = id.as_mut();
4694
4695 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4696
4697 let _field = client_end.as_mut();
4698
4699 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
4700
4701 Ok(())
4702 }
4703 }
4704
4705 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
4706 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
4707 }
4708
4709 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportRequest {}
4710
4711 #[derive(Debug)]
4713 #[repr(C)]
4714 pub struct CapabilityStoreDictionaryLegacyExportRequest {
4715 pub id: ::fidl_next::WireU64,
4716
4717 pub server_end: ::fidl_next::fuchsia::WireChannel,
4718 }
4719
4720 static_assertions::const_assert_eq!(
4721 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4722 16
4723 );
4724 static_assertions::const_assert_eq!(
4725 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4726 8
4727 );
4728
4729 static_assertions::const_assert_eq!(
4730 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
4731 0
4732 );
4733
4734 static_assertions::const_assert_eq!(
4735 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
4736 8
4737 );
4738
4739 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
4740 type Owned<'de> = CapabilityStoreDictionaryLegacyExportRequest;
4741
4742 #[inline]
4743 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4744 ::fidl_next::munge! {
4745 let Self {
4746
4747 id,
4748 server_end,
4749
4750 } = &mut *out_;
4751 }
4752
4753 ::fidl_next::Wire::zero_padding(id);
4754
4755 ::fidl_next::Wire::zero_padding(server_end);
4756
4757 unsafe {
4758 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4759 }
4760 }
4761 }
4762
4763 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
4764 where
4765 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4766 ___D: ::fidl_next::fuchsia::HandleDecoder,
4767 {
4768 fn decode(
4769 slot_: ::fidl_next::Slot<'_, Self>,
4770 decoder_: &mut ___D,
4771 _: (),
4772 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4773 if slot_.as_bytes()[12..16] != [0u8; 4] {
4774 return Err(::fidl_next::DecodeError::InvalidPadding);
4775 }
4776
4777 ::fidl_next::munge! {
4778 let Self {
4779
4780 mut id,
4781 mut server_end,
4782
4783 } = slot_;
4784 }
4785
4786 let _field = id.as_mut();
4787
4788 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4789
4790 let _field = server_end.as_mut();
4791
4792 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4793
4794 Ok(())
4795 }
4796 }
4797
4798 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
4799 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
4800 }
4801
4802 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportRequest {}
4803
4804 #[derive(Debug)]
4806 #[repr(C)]
4807 pub struct CapabilityStoreDictionaryKeysRequest {
4808 pub id: ::fidl_next::WireU64,
4809
4810 pub iterator: ::fidl_next::ServerEnd<
4811 crate::DictionaryKeysIterator,
4812 ::fidl_next::fuchsia::WireChannel,
4813 >,
4814 }
4815
4816 static_assertions::const_assert_eq!(
4817 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
4818 16
4819 );
4820 static_assertions::const_assert_eq!(
4821 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
4822 8
4823 );
4824
4825 static_assertions::const_assert_eq!(
4826 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
4827 0
4828 );
4829
4830 static_assertions::const_assert_eq!(
4831 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
4832 8
4833 );
4834
4835 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
4836 type Owned<'de> = CapabilityStoreDictionaryKeysRequest;
4837
4838 #[inline]
4839 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4840 ::fidl_next::munge! {
4841 let Self {
4842
4843 id,
4844 iterator,
4845
4846 } = &mut *out_;
4847 }
4848
4849 ::fidl_next::Wire::zero_padding(id);
4850
4851 ::fidl_next::Wire::zero_padding(iterator);
4852
4853 unsafe {
4854 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4855 }
4856 }
4857 }
4858
4859 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
4860 where
4861 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4862 ___D: ::fidl_next::fuchsia::HandleDecoder,
4863 {
4864 fn decode(
4865 slot_: ::fidl_next::Slot<'_, Self>,
4866 decoder_: &mut ___D,
4867 _: (),
4868 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4869 if slot_.as_bytes()[12..16] != [0u8; 4] {
4870 return Err(::fidl_next::DecodeError::InvalidPadding);
4871 }
4872
4873 ::fidl_next::munge! {
4874 let Self {
4875
4876 mut id,
4877 mut iterator,
4878
4879 } = slot_;
4880 }
4881
4882 let _field = id.as_mut();
4883
4884 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4885
4886 let _field = iterator.as_mut();
4887
4888 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4889
4890 Ok(())
4891 }
4892 }
4893
4894 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
4895 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
4896 }
4897
4898 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysRequest {}
4899
4900 #[derive(Debug)]
4902 #[repr(C)]
4903 pub struct CapabilityStoreDictionaryEnumerateRequest {
4904 pub id: ::fidl_next::WireU64,
4905
4906 pub iterator: ::fidl_next::ServerEnd<
4907 crate::DictionaryEnumerateIterator,
4908 ::fidl_next::fuchsia::WireChannel,
4909 >,
4910 }
4911
4912 static_assertions::const_assert_eq!(
4913 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4914 16
4915 );
4916 static_assertions::const_assert_eq!(
4917 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
4918 8
4919 );
4920
4921 static_assertions::const_assert_eq!(
4922 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
4923 0
4924 );
4925
4926 static_assertions::const_assert_eq!(
4927 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
4928 8
4929 );
4930
4931 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
4932 type Owned<'de> = CapabilityStoreDictionaryEnumerateRequest;
4933
4934 #[inline]
4935 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4936 ::fidl_next::munge! {
4937 let Self {
4938
4939 id,
4940 iterator,
4941
4942 } = &mut *out_;
4943 }
4944
4945 ::fidl_next::Wire::zero_padding(id);
4946
4947 ::fidl_next::Wire::zero_padding(iterator);
4948
4949 unsafe {
4950 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4951 }
4952 }
4953 }
4954
4955 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
4956 where
4957 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4958 ___D: ::fidl_next::fuchsia::HandleDecoder,
4959 {
4960 fn decode(
4961 slot_: ::fidl_next::Slot<'_, Self>,
4962 decoder_: &mut ___D,
4963 _: (),
4964 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4965 if slot_.as_bytes()[12..16] != [0u8; 4] {
4966 return Err(::fidl_next::DecodeError::InvalidPadding);
4967 }
4968
4969 ::fidl_next::munge! {
4970 let Self {
4971
4972 mut id,
4973 mut iterator,
4974
4975 } = slot_;
4976 }
4977
4978 let _field = id.as_mut();
4979
4980 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4981
4982 let _field = iterator.as_mut();
4983
4984 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
4985
4986 Ok(())
4987 }
4988 }
4989
4990 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
4991 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
4992 }
4993
4994 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateRequest {}
4995
4996 #[derive(Debug)]
4998 #[repr(C)]
4999 pub struct CapabilityStoreDictionaryDrainRequest {
5000 pub id: ::fidl_next::WireU64,
5001
5002 pub iterator: ::fidl_next::ServerEnd<
5003 crate::DictionaryDrainIterator,
5004 ::fidl_next::fuchsia::WireOptionalChannel,
5005 >,
5006 }
5007
5008 static_assertions::const_assert_eq!(
5009 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
5010 16
5011 );
5012 static_assertions::const_assert_eq!(
5013 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
5014 8
5015 );
5016
5017 static_assertions::const_assert_eq!(
5018 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
5019 0
5020 );
5021
5022 static_assertions::const_assert_eq!(
5023 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
5024 8
5025 );
5026
5027 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
5028 type Owned<'de> = CapabilityStoreDictionaryDrainRequest;
5029
5030 #[inline]
5031 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5032 ::fidl_next::munge! {
5033 let Self {
5034
5035 id,
5036 iterator,
5037
5038 } = &mut *out_;
5039 }
5040
5041 ::fidl_next::Wire::zero_padding(id);
5042
5043 ::fidl_next::Wire::zero_padding(iterator);
5044
5045 unsafe {
5046 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5047 }
5048 }
5049 }
5050
5051 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
5052 where
5053 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5054 ___D: ::fidl_next::fuchsia::HandleDecoder,
5055 {
5056 fn decode(
5057 slot_: ::fidl_next::Slot<'_, Self>,
5058 decoder_: &mut ___D,
5059 _: (),
5060 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5061 if slot_.as_bytes()[12..16] != [0u8; 4] {
5062 return Err(::fidl_next::DecodeError::InvalidPadding);
5063 }
5064
5065 ::fidl_next::munge! {
5066 let Self {
5067
5068 mut id,
5069 mut iterator,
5070
5071 } = slot_;
5072 }
5073
5074 let _field = id.as_mut();
5075
5076 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5077
5078 let _field = iterator.as_mut();
5079
5080 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5081
5082 Ok(())
5083 }
5084 }
5085
5086 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
5087 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
5088 }
5089
5090 impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainRequest {}
5091
5092 #[derive(Debug)]
5094 #[repr(C)]
5095 pub struct CapabilityStoreCreateServiceAggregateRequest<'de> {
5096 pub sources: ::fidl_next::WireVector<'de, crate::wire::AggregateSource<'de>>,
5097 }
5098
5099 static_assertions::const_assert_eq!(
5100 std::mem::size_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5101 16
5102 );
5103 static_assertions::const_assert_eq!(
5104 std::mem::align_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5105 8
5106 );
5107
5108 static_assertions::const_assert_eq!(
5109 std::mem::offset_of!(CapabilityStoreCreateServiceAggregateRequest<'_>, sources),
5110 0
5111 );
5112
5113 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateRequest<'static> {
5114 type Owned<'de> = CapabilityStoreCreateServiceAggregateRequest<'de>;
5115
5116 #[inline]
5117 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5118 ::fidl_next::munge! {
5119 let Self {
5120
5121 sources,
5122
5123 } = &mut *out_;
5124 }
5125
5126 ::fidl_next::Wire::zero_padding(sources);
5127 }
5128 }
5129
5130 unsafe impl<___D> ::fidl_next::Decode<___D>
5131 for CapabilityStoreCreateServiceAggregateRequest<'static>
5132 where
5133 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5134 ___D: ::fidl_next::Decoder,
5135 ___D: ::fidl_next::fuchsia::HandleDecoder,
5136 {
5137 fn decode(
5138 slot_: ::fidl_next::Slot<'_, Self>,
5139 decoder_: &mut ___D,
5140 _: (),
5141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5142 ::fidl_next::munge! {
5143 let Self {
5144
5145 mut sources,
5146
5147 } = slot_;
5148 }
5149
5150 let _field = sources.as_mut();
5151 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5152 ::fidl_next::Decode::decode(sources.as_mut(), decoder_, (4294967295, ()))?;
5153
5154 Ok(())
5155 }
5156 }
5157
5158 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateRequest<'de> {
5159 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateRequest;
5160 }
5161
5162 impl ::fidl_next::Unconstrained for CapabilityStoreCreateServiceAggregateRequest<'static> {}
5163
5164 #[derive(Debug)]
5166 #[repr(C)]
5167 pub struct CapabilityStoreCreateServiceAggregateResponse {
5168 pub aggregate_dir_connector: crate::wire::DirConnector,
5169 }
5170
5171 static_assertions::const_assert_eq!(
5172 std::mem::size_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5173 4
5174 );
5175 static_assertions::const_assert_eq!(
5176 std::mem::align_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5177 4
5178 );
5179
5180 static_assertions::const_assert_eq!(
5181 std::mem::offset_of!(
5182 CapabilityStoreCreateServiceAggregateResponse,
5183 aggregate_dir_connector
5184 ),
5185 0
5186 );
5187
5188 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateResponse {
5189 type Owned<'de> = CapabilityStoreCreateServiceAggregateResponse;
5190
5191 #[inline]
5192 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5193 ::fidl_next::munge! {
5194 let Self {
5195
5196 aggregate_dir_connector,
5197
5198 } = &mut *out_;
5199 }
5200
5201 ::fidl_next::Wire::zero_padding(aggregate_dir_connector);
5202 }
5203 }
5204
5205 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreCreateServiceAggregateResponse
5206 where
5207 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5208 ___D: ::fidl_next::fuchsia::HandleDecoder,
5209 {
5210 fn decode(
5211 slot_: ::fidl_next::Slot<'_, Self>,
5212 decoder_: &mut ___D,
5213 _: (),
5214 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5215 ::fidl_next::munge! {
5216 let Self {
5217
5218 mut aggregate_dir_connector,
5219
5220 } = slot_;
5221 }
5222
5223 let _field = aggregate_dir_connector.as_mut();
5224
5225 ::fidl_next::Decode::decode(aggregate_dir_connector.as_mut(), decoder_, ())?;
5226
5227 Ok(())
5228 }
5229 }
5230
5231 impl ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateResponse {
5232 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateResponse;
5233 }
5234
5235 impl ::fidl_next::Unconstrained for CapabilityStoreCreateServiceAggregateResponse {}
5236
5237 #[derive(Debug)]
5239 #[repr(C)]
5240 pub struct CapabilityStoreExportResponse<'de> {
5241 pub capability: crate::wire::Capability<'de>,
5242 }
5243
5244 static_assertions::const_assert_eq!(
5245 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
5246 16
5247 );
5248 static_assertions::const_assert_eq!(
5249 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
5250 8
5251 );
5252
5253 static_assertions::const_assert_eq!(
5254 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
5255 0
5256 );
5257
5258 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
5259 type Owned<'de> = CapabilityStoreExportResponse<'de>;
5260
5261 #[inline]
5262 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5263 ::fidl_next::munge! {
5264 let Self {
5265
5266 capability,
5267
5268 } = &mut *out_;
5269 }
5270
5271 ::fidl_next::Wire::zero_padding(capability);
5272 }
5273 }
5274
5275 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'static>
5276 where
5277 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5278 ___D: ::fidl_next::Decoder,
5279 ___D: ::fidl_next::fuchsia::HandleDecoder,
5280 {
5281 fn decode(
5282 slot_: ::fidl_next::Slot<'_, Self>,
5283 decoder_: &mut ___D,
5284 _: (),
5285 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5286 ::fidl_next::munge! {
5287 let Self {
5288
5289 mut capability,
5290
5291 } = slot_;
5292 }
5293
5294 let _field = capability.as_mut();
5295
5296 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5297
5298 Ok(())
5299 }
5300 }
5301
5302 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
5303 type Natural = crate::natural::CapabilityStoreExportResponse;
5304 }
5305
5306 impl ::fidl_next::Unconstrained for CapabilityStoreExportResponse<'static> {}
5307
5308 #[derive(Debug)]
5310 #[repr(C)]
5311 pub struct CapabilityStoreImportRequest<'de> {
5312 pub id: ::fidl_next::WireU64,
5313
5314 pub capability: crate::wire::Capability<'de>,
5315 }
5316
5317 static_assertions::const_assert_eq!(
5318 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
5319 24
5320 );
5321 static_assertions::const_assert_eq!(
5322 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
5323 8
5324 );
5325
5326 static_assertions::const_assert_eq!(
5327 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
5328 0
5329 );
5330
5331 static_assertions::const_assert_eq!(
5332 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
5333 8
5334 );
5335
5336 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
5337 type Owned<'de> = CapabilityStoreImportRequest<'de>;
5338
5339 #[inline]
5340 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5341 ::fidl_next::munge! {
5342 let Self {
5343
5344 id,
5345 capability,
5346
5347 } = &mut *out_;
5348 }
5349
5350 ::fidl_next::Wire::zero_padding(id);
5351
5352 ::fidl_next::Wire::zero_padding(capability);
5353 }
5354 }
5355
5356 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'static>
5357 where
5358 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5359 ___D: ::fidl_next::Decoder,
5360 ___D: ::fidl_next::fuchsia::HandleDecoder,
5361 {
5362 fn decode(
5363 slot_: ::fidl_next::Slot<'_, Self>,
5364 decoder_: &mut ___D,
5365 _: (),
5366 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5367 ::fidl_next::munge! {
5368 let Self {
5369
5370 mut id,
5371 mut capability,
5372
5373 } = slot_;
5374 }
5375
5376 let _field = id.as_mut();
5377
5378 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5379
5380 let _field = capability.as_mut();
5381
5382 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5383
5384 Ok(())
5385 }
5386 }
5387
5388 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
5389 type Natural = crate::natural::CapabilityStoreImportRequest;
5390 }
5391
5392 impl ::fidl_next::Unconstrained for CapabilityStoreImportRequest<'static> {}
5393
5394 #[repr(C)]
5396 pub struct CapabilityStoreDirConnectorOpenRequest<'de> {
5397 pub(crate) table: ::fidl_next::WireTable<'de>,
5398 }
5399
5400 impl<'de> Drop for CapabilityStoreDirConnectorOpenRequest<'de> {
5401 fn drop(&mut self) {
5402 let _ = self
5403 .table
5404 .get(1)
5405 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });
5406
5407 let _ = self.table.get(2).map(|envelope| unsafe {
5408 envelope.read_unchecked::<::fidl_next::ServerEnd<
5409 ::fidl_next_fuchsia_io::Directory,
5410 ::fidl_next::fuchsia::WireChannel,
5411 >>()
5412 });
5413
5414 let _ = self.table.get(3).map(|envelope| unsafe {
5415 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
5416 });
5417
5418 let _ = self.table.get(4).map(|envelope| unsafe {
5419 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
5420 });
5421 }
5422 }
5423
5424 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest<'static> {
5425 type Owned<'de> = CapabilityStoreDirConnectorOpenRequest<'de>;
5426
5427 #[inline]
5428 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5429 ::fidl_next::munge!(let Self { table } = out);
5430 ::fidl_next::WireTable::zero_padding(table);
5431 }
5432 }
5433
5434 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest<'static>
5435 where
5436 ___D: ::fidl_next::Decoder + ?Sized,
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!(let Self { table } = slot);
5445
5446 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5447 match ordinal {
5448 0 => unsafe { ::core::hint::unreachable_unchecked() },
5449
5450 1 => {
5451 ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
5452 slot.as_mut(),
5453 decoder,
5454 (),
5455 )?;
5456
5457 Ok(())
5458 }
5459
5460 2 => {
5461 ::fidl_next::WireEnvelope::decode_as::<
5462 ___D,
5463 ::fidl_next::ServerEnd<
5464 ::fidl_next_fuchsia_io::Directory,
5465 ::fidl_next::fuchsia::WireChannel,
5466 >,
5467 >(slot.as_mut(), decoder, ())?;
5468
5469 Ok(())
5470 }
5471
5472 3 => {
5473 ::fidl_next::WireEnvelope::decode_as::<
5474 ___D,
5475 ::fidl_next_fuchsia_io::wire::Flags,
5476 >(slot.as_mut(), decoder, ())?;
5477
5478 Ok(())
5479 }
5480
5481 4 => {
5482 ::fidl_next::WireEnvelope::decode_as::<
5483 ___D,
5484 ::fidl_next::WireString<'static>,
5485 >(slot.as_mut(), decoder, 4095)?;
5486
5487 let value = unsafe {
5488 slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
5489 };
5490
5491 if value.len() > 4095 {
5492 return Err(::fidl_next::DecodeError::VectorTooLong {
5493 size: value.len() as u64,
5494 limit: 4095,
5495 });
5496 }
5497
5498 Ok(())
5499 }
5500
5501 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
5502 }
5503 })
5504 }
5505 }
5506
5507 impl<'de> CapabilityStoreDirConnectorOpenRequest<'de> {
5508 pub fn id(&self) -> ::core::option::Option<&::fidl_next::WireU64> {
5509 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5510 }
5511
5512 pub fn server_end(
5513 &self,
5514 ) -> ::core::option::Option<
5515 &::fidl_next::ServerEnd<
5516 ::fidl_next_fuchsia_io::Directory,
5517 ::fidl_next::fuchsia::WireChannel,
5518 >,
5519 > {
5520 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5521 }
5522
5523 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
5524 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
5525 }
5526
5527 pub fn path(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
5528 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
5529 }
5530 }
5531
5532 impl<'de> ::core::fmt::Debug for CapabilityStoreDirConnectorOpenRequest<'de> {
5533 fn fmt(
5534 &self,
5535 f: &mut ::core::fmt::Formatter<'_>,
5536 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5537 f.debug_struct("CapabilityStoreDirConnectorOpenRequest")
5538 .field("id", &self.id())
5539 .field("server_end", &self.server_end())
5540 .field("flags", &self.flags())
5541 .field("path", &self.path())
5542 .finish()
5543 }
5544 }
5545
5546 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest<'de> {
5547 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
5548 }
5549
5550 impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenRequest<'_> {}
5551
5552 #[derive(Debug)]
5554 #[repr(C)]
5555 pub struct InstanceToken {
5556 pub token: ::fidl_next::fuchsia::WireEventPair,
5557 }
5558
5559 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
5560 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
5561
5562 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
5563
5564 unsafe impl ::fidl_next::Wire for InstanceToken {
5565 type Owned<'de> = InstanceToken;
5566
5567 #[inline]
5568 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5569 ::fidl_next::munge! {
5570 let Self {
5571
5572 token,
5573
5574 } = &mut *out_;
5575 }
5576
5577 ::fidl_next::Wire::zero_padding(token);
5578 }
5579 }
5580
5581 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
5582 where
5583 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5584 ___D: ::fidl_next::fuchsia::HandleDecoder,
5585 {
5586 fn decode(
5587 slot_: ::fidl_next::Slot<'_, Self>,
5588 decoder_: &mut ___D,
5589 _: (),
5590 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5591 ::fidl_next::munge! {
5592 let Self {
5593
5594 mut token,
5595
5596 } = slot_;
5597 }
5598
5599 let _field = token.as_mut();
5600
5601 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
5602
5603 Ok(())
5604 }
5605 }
5606
5607 impl ::fidl_next::IntoNatural for InstanceToken {
5608 type Natural = crate::natural::InstanceToken;
5609 }
5610
5611 impl ::fidl_next::Unconstrained for InstanceToken {}
5612
5613 #[repr(C)]
5615 pub struct RouteRequest<'de> {
5616 pub(crate) table: ::fidl_next::WireTable<'de>,
5617 }
5618
5619 impl<'de> Drop for RouteRequest<'de> {
5620 fn drop(&mut self) {
5621 let _ = self
5622 .table
5623 .get(1)
5624 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
5625
5626 let _ = self
5627 .table
5628 .get(2)
5629 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
5630 }
5631 }
5632
5633 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
5634 type Owned<'de> = RouteRequest<'de>;
5635
5636 #[inline]
5637 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5638 ::fidl_next::munge!(let Self { table } = out);
5639 ::fidl_next::WireTable::zero_padding(table);
5640 }
5641 }
5642
5643 unsafe impl<___D> ::fidl_next::Decode<___D> for RouteRequest<'static>
5644 where
5645 ___D: ::fidl_next::Decoder + ?Sized,
5646 ___D: ::fidl_next::fuchsia::HandleDecoder,
5647 {
5648 fn decode(
5649 slot: ::fidl_next::Slot<'_, Self>,
5650 decoder: &mut ___D,
5651 _: (),
5652 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5653 ::fidl_next::munge!(let Self { table } = slot);
5654
5655 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5656 match ordinal {
5657 0 => unsafe { ::core::hint::unreachable_unchecked() },
5658
5659 1 => {
5660 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::InstanceToken>(
5661 slot.as_mut(),
5662 decoder,
5663 (),
5664 )?;
5665
5666 Ok(())
5667 }
5668
5669 2 => {
5670 ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DictionaryRef>(
5671 slot.as_mut(),
5672 decoder,
5673 (),
5674 )?;
5675
5676 Ok(())
5677 }
5678
5679 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
5680 }
5681 })
5682 }
5683 }
5684
5685 impl<'de> RouteRequest<'de> {
5686 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
5687 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5688 }
5689
5690 pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
5691 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5692 }
5693 }
5694
5695 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
5696 fn fmt(
5697 &self,
5698 f: &mut ::core::fmt::Formatter<'_>,
5699 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5700 f.debug_struct("RouteRequest")
5701 .field("requesting", &self.requesting())
5702 .field("metadata", &self.metadata())
5703 .finish()
5704 }
5705 }
5706
5707 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
5708 type Natural = crate::natural::RouteRequest;
5709 }
5710
5711 impl ::fidl_next::Unconstrained for RouteRequest<'_> {}
5712
5713 #[repr(transparent)]
5715 pub struct ConnectorRouterRouteResponse {
5716 pub(crate) raw: ::fidl_next::RawWireUnion,
5717 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5718 }
5719
5720 impl Drop for ConnectorRouterRouteResponse {
5721 fn drop(&mut self) {
5722 match self.raw.ordinal() {
5723 1 => {
5724 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
5725 }
5726
5727 2 => {
5728 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5729 }
5730
5731 _ => unsafe { ::core::hint::unreachable_unchecked() },
5732 }
5733 }
5734 }
5735
5736 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
5737 type Owned<'de> = ConnectorRouterRouteResponse;
5738
5739 #[inline]
5740 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5741 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5742 ::fidl_next::RawWireUnion::zero_padding(raw);
5743 }
5744 }
5745
5746 pub mod connector_router_route_response {
5747 pub enum Ref<'de> {
5748 Connector(&'de crate::wire::Connector),
5749
5750 Unavailable(&'de crate::wire::Unit),
5751 }
5752 }
5753
5754 impl ConnectorRouterRouteResponse {
5755 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
5756 match self.raw.ordinal() {
5757 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
5758 self.raw.get().deref_unchecked::<crate::wire::Connector>()
5759 }),
5760
5761 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
5762 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5763 }),
5764
5765 _ => unsafe { ::core::hint::unreachable_unchecked() },
5766 }
5767 }
5768 }
5769
5770 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
5771 where
5772 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5773 ___D: ::fidl_next::fuchsia::HandleDecoder,
5774 {
5775 fn decode(
5776 mut slot: ::fidl_next::Slot<'_, Self>,
5777 decoder: &mut ___D,
5778 _: (),
5779 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5780 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5781 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5782 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
5783 raw,
5784 decoder,
5785 (),
5786 )?,
5787
5788 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
5789 raw,
5790 decoder,
5791 (),
5792 )?,
5793
5794 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5795 }
5796
5797 Ok(())
5798 }
5799 }
5800
5801 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
5802 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5803 match self.raw.ordinal() {
5804 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
5805 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5806 _ => unsafe { ::core::hint::unreachable_unchecked() },
5807 }
5808 }
5809 }
5810
5811 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
5812 type Natural = crate::natural::ConnectorRouterRouteResponse;
5813 }
5814
5815 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
5816
5817 #[repr(transparent)]
5819 pub struct DataRouterRouteResponse<'de> {
5820 pub(crate) raw: ::fidl_next::RawWireUnion,
5821 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
5822 }
5823
5824 impl<'de> Drop for DataRouterRouteResponse<'de> {
5825 fn drop(&mut self) {
5826 match self.raw.ordinal() {
5827 1 => {
5828 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
5829 }
5830
5831 2 => {
5832 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5833 }
5834
5835 _ => unsafe { ::core::hint::unreachable_unchecked() },
5836 }
5837 }
5838 }
5839
5840 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
5841 type Owned<'de> = DataRouterRouteResponse<'de>;
5842
5843 #[inline]
5844 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5845 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5846 ::fidl_next::RawWireUnion::zero_padding(raw);
5847 }
5848 }
5849
5850 pub mod data_router_route_response {
5851 pub enum Ref<'de> {
5852 Data(&'de crate::wire::Data<'de>),
5853
5854 Unavailable(&'de crate::wire::Unit),
5855 }
5856 }
5857
5858 impl<'de> DataRouterRouteResponse<'de> {
5859 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
5860 match self.raw.ordinal() {
5861 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
5862 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
5863 }),
5864
5865 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
5866 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5867 }),
5868
5869 _ => unsafe { ::core::hint::unreachable_unchecked() },
5870 }
5871 }
5872 }
5873
5874 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
5875 where
5876 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5877 ___D: ::fidl_next::Decoder,
5878 ___D: ::fidl_next::fuchsia::HandleDecoder,
5879 {
5880 fn decode(
5881 mut slot: ::fidl_next::Slot<'_, Self>,
5882 decoder: &mut ___D,
5883 _: (),
5884 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5885 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
5886 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
5887 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
5888 raw,
5889 decoder,
5890 (),
5891 )?,
5892
5893 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
5894 raw,
5895 decoder,
5896 (),
5897 )?,
5898
5899 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
5900 }
5901
5902 Ok(())
5903 }
5904 }
5905
5906 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
5907 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5908 match self.raw.ordinal() {
5909 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
5910 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
5911 _ => unsafe { ::core::hint::unreachable_unchecked() },
5912 }
5913 }
5914 }
5915
5916 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
5917 type Natural = crate::natural::DataRouterRouteResponse;
5918 }
5919
5920 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
5921
5922 #[derive(Debug)]
5924 #[repr(C)]
5925 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
5926 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryItem<'de>>,
5927
5928 pub end_id: ::fidl_next::WireU64,
5929 }
5930
5931 static_assertions::const_assert_eq!(
5932 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5933 24
5934 );
5935 static_assertions::const_assert_eq!(
5936 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
5937 8
5938 );
5939
5940 static_assertions::const_assert_eq!(
5941 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
5942 0
5943 );
5944
5945 static_assertions::const_assert_eq!(
5946 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
5947 16
5948 );
5949
5950 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
5951 type Owned<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
5952
5953 #[inline]
5954 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5955 ::fidl_next::munge! {
5956 let Self {
5957
5958 items,
5959 end_id,
5960
5961 } = &mut *out_;
5962 }
5963
5964 ::fidl_next::Wire::zero_padding(items);
5965
5966 ::fidl_next::Wire::zero_padding(end_id);
5967 }
5968 }
5969
5970 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'static>
5971 where
5972 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5973 ___D: ::fidl_next::Decoder,
5974 ___D: ::fidl_next::fuchsia::HandleDecoder,
5975 {
5976 fn decode(
5977 slot_: ::fidl_next::Slot<'_, Self>,
5978 decoder_: &mut ___D,
5979 _: (),
5980 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5981 ::fidl_next::munge! {
5982 let Self {
5983
5984 mut items,
5985 mut end_id,
5986
5987 } = slot_;
5988 }
5989
5990 let _field = items.as_mut();
5991 ::fidl_next::Constrained::validate(_field, (128, ()))?;
5992 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
5993
5994 let items = unsafe { items.deref_unchecked() };
5995
5996 if items.len() > 128 {
5997 return Err(::fidl_next::DecodeError::VectorTooLong {
5998 size: items.len() as u64,
5999 limit: 128,
6000 });
6001 }
6002
6003 let _field = end_id.as_mut();
6004
6005 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6006
6007 Ok(())
6008 }
6009 }
6010
6011 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
6012 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
6013 }
6014
6015 impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextResponse<'static> {}
6016
6017 #[derive(Debug)]
6019 #[repr(C)]
6020 pub struct DictionaryOptionalItem<'de> {
6021 pub key: ::fidl_next::WireString<'de>,
6022
6023 pub value: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
6024 }
6025
6026 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
6027 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
6028
6029 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
6030
6031 static_assertions::const_assert_eq!(
6032 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
6033 16
6034 );
6035
6036 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
6037 type Owned<'de> = DictionaryOptionalItem<'de>;
6038
6039 #[inline]
6040 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6041 ::fidl_next::munge! {
6042 let Self {
6043
6044 key,
6045 value,
6046
6047 } = &mut *out_;
6048 }
6049
6050 ::fidl_next::Wire::zero_padding(key);
6051
6052 ::fidl_next::Wire::zero_padding(value);
6053 }
6054 }
6055
6056 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'static>
6057 where
6058 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6059 ___D: ::fidl_next::Decoder,
6060 ___D: ::fidl_next::fuchsia::HandleDecoder,
6061 {
6062 fn decode(
6063 slot_: ::fidl_next::Slot<'_, Self>,
6064 decoder_: &mut ___D,
6065 _: (),
6066 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6067 ::fidl_next::munge! {
6068 let Self {
6069
6070 mut key,
6071 mut value,
6072
6073 } = slot_;
6074 }
6075
6076 let _field = key.as_mut();
6077 ::fidl_next::Constrained::validate(_field, 255)?;
6078 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
6079
6080 let key = unsafe { key.deref_unchecked() };
6081
6082 if key.len() > 255 {
6083 return Err(::fidl_next::DecodeError::VectorTooLong {
6084 size: key.len() as u64,
6085 limit: 255,
6086 });
6087 }
6088
6089 let _field = value.as_mut();
6090
6091 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
6092
6093 Ok(())
6094 }
6095 }
6096
6097 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
6098 type Natural = crate::natural::DictionaryOptionalItem;
6099 }
6100
6101 impl ::fidl_next::Unconstrained for DictionaryOptionalItem<'static> {}
6102
6103 #[derive(Debug)]
6105 #[repr(C)]
6106 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
6107 pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryOptionalItem<'de>>,
6108
6109 pub end_id: ::fidl_next::WireU64,
6110 }
6111
6112 static_assertions::const_assert_eq!(
6113 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6114 24
6115 );
6116 static_assertions::const_assert_eq!(
6117 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6118 8
6119 );
6120
6121 static_assertions::const_assert_eq!(
6122 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
6123 0
6124 );
6125
6126 static_assertions::const_assert_eq!(
6127 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
6128 16
6129 );
6130
6131 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
6132 type Owned<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
6133
6134 #[inline]
6135 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6136 ::fidl_next::munge! {
6137 let Self {
6138
6139 items,
6140 end_id,
6141
6142 } = &mut *out_;
6143 }
6144
6145 ::fidl_next::Wire::zero_padding(items);
6146
6147 ::fidl_next::Wire::zero_padding(end_id);
6148 }
6149 }
6150
6151 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'static>
6152 where
6153 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6154 ___D: ::fidl_next::Decoder,
6155 ___D: ::fidl_next::fuchsia::HandleDecoder,
6156 {
6157 fn decode(
6158 slot_: ::fidl_next::Slot<'_, Self>,
6159 decoder_: &mut ___D,
6160 _: (),
6161 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6162 ::fidl_next::munge! {
6163 let Self {
6164
6165 mut items,
6166 mut end_id,
6167
6168 } = slot_;
6169 }
6170
6171 let _field = items.as_mut();
6172 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6173 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
6174
6175 let items = unsafe { items.deref_unchecked() };
6176
6177 if items.len() > 128 {
6178 return Err(::fidl_next::DecodeError::VectorTooLong {
6179 size: items.len() as u64,
6180 limit: 128,
6181 });
6182 }
6183
6184 let _field = end_id.as_mut();
6185
6186 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6187
6188 Ok(())
6189 }
6190 }
6191
6192 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
6193 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
6194 }
6195
6196 impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextResponse<'static> {}
6197
6198 #[derive(Debug)]
6200 #[repr(C)]
6201 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
6202 pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
6203 }
6204
6205 static_assertions::const_assert_eq!(
6206 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6207 16
6208 );
6209 static_assertions::const_assert_eq!(
6210 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6211 8
6212 );
6213
6214 static_assertions::const_assert_eq!(
6215 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
6216 0
6217 );
6218
6219 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
6220 type Owned<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
6221
6222 #[inline]
6223 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6224 ::fidl_next::munge! {
6225 let Self {
6226
6227 keys,
6228
6229 } = &mut *out_;
6230 }
6231
6232 ::fidl_next::Wire::zero_padding(keys);
6233 }
6234 }
6235
6236 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'static>
6237 where
6238 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6239 ___D: ::fidl_next::Decoder,
6240 ___D: ::fidl_next::fuchsia::HandleDecoder,
6241 {
6242 fn decode(
6243 slot_: ::fidl_next::Slot<'_, Self>,
6244 decoder_: &mut ___D,
6245 _: (),
6246 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6247 ::fidl_next::munge! {
6248 let Self {
6249
6250 mut keys,
6251
6252 } = slot_;
6253 }
6254
6255 let _field = keys.as_mut();
6256 ::fidl_next::Constrained::validate(_field, (128, 255))?;
6257 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
6258
6259 let keys = unsafe { keys.deref_unchecked() };
6260
6261 if keys.len() > 128 {
6262 return Err(::fidl_next::DecodeError::VectorTooLong {
6263 size: keys.len() as u64,
6264 limit: 128,
6265 });
6266 }
6267
6268 Ok(())
6269 }
6270 }
6271
6272 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
6273 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
6274 }
6275
6276 impl ::fidl_next::Unconstrained for DictionaryKeysIteratorGetNextResponse<'static> {}
6277
6278 #[repr(transparent)]
6280 pub struct DictionaryRouterRouteResponse {
6281 pub(crate) raw: ::fidl_next::RawWireUnion,
6282 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6283 }
6284
6285 impl Drop for DictionaryRouterRouteResponse {
6286 fn drop(&mut self) {
6287 match self.raw.ordinal() {
6288 1 => {
6289 let _ =
6290 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
6291 }
6292
6293 2 => {
6294 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6295 }
6296
6297 _ => unsafe { ::core::hint::unreachable_unchecked() },
6298 }
6299 }
6300 }
6301
6302 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
6303 type Owned<'de> = DictionaryRouterRouteResponse;
6304
6305 #[inline]
6306 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6307 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6308 ::fidl_next::RawWireUnion::zero_padding(raw);
6309 }
6310 }
6311
6312 pub mod dictionary_router_route_response {
6313 pub enum Ref<'de> {
6314 Dictionary(&'de crate::wire::DictionaryRef),
6315
6316 Unavailable(&'de crate::wire::Unit),
6317 }
6318 }
6319
6320 impl DictionaryRouterRouteResponse {
6321 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
6322 match self.raw.ordinal() {
6323 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
6324 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
6325 }),
6326
6327 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
6328 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6329 }),
6330
6331 _ => unsafe { ::core::hint::unreachable_unchecked() },
6332 }
6333 }
6334 }
6335
6336 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
6337 where
6338 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
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 => {
6349 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
6350 raw,
6351 decoder,
6352 (),
6353 )?
6354 }
6355
6356 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6357 raw,
6358 decoder,
6359 (),
6360 )?,
6361
6362 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6363 }
6364
6365 Ok(())
6366 }
6367 }
6368
6369 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
6370 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6371 match self.raw.ordinal() {
6372 1 => unsafe {
6373 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
6374 },
6375 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6376 _ => unsafe { ::core::hint::unreachable_unchecked() },
6377 }
6378 }
6379 }
6380
6381 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
6382 type Natural = crate::natural::DictionaryRouterRouteResponse;
6383 }
6384
6385 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
6386
6387 #[repr(transparent)]
6389 pub struct DirConnectorRouterRouteResponse {
6390 pub(crate) raw: ::fidl_next::RawWireUnion,
6391 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6392 }
6393
6394 impl Drop for DirConnectorRouterRouteResponse {
6395 fn drop(&mut self) {
6396 match self.raw.ordinal() {
6397 1 => {
6398 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
6399 }
6400
6401 2 => {
6402 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6403 }
6404
6405 _ => unsafe { ::core::hint::unreachable_unchecked() },
6406 }
6407 }
6408 }
6409
6410 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
6411 type Owned<'de> = DirConnectorRouterRouteResponse;
6412
6413 #[inline]
6414 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6415 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6416 ::fidl_next::RawWireUnion::zero_padding(raw);
6417 }
6418 }
6419
6420 pub mod dir_connector_router_route_response {
6421 pub enum Ref<'de> {
6422 DirConnector(&'de crate::wire::DirConnector),
6423
6424 Unavailable(&'de crate::wire::Unit),
6425 }
6426 }
6427
6428 impl DirConnectorRouterRouteResponse {
6429 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
6430 match self.raw.ordinal() {
6431 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
6432 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
6433 }),
6434
6435 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
6436 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6437 }),
6438
6439 _ => unsafe { ::core::hint::unreachable_unchecked() },
6440 }
6441 }
6442 }
6443
6444 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
6445 where
6446 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6447 ___D: ::fidl_next::fuchsia::HandleDecoder,
6448 {
6449 fn decode(
6450 mut slot: ::fidl_next::Slot<'_, Self>,
6451 decoder: &mut ___D,
6452 _: (),
6453 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6454 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6455 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6456 1 => {
6457 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
6458 raw,
6459 decoder,
6460 (),
6461 )?
6462 }
6463
6464 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6465 raw,
6466 decoder,
6467 (),
6468 )?,
6469
6470 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6471 }
6472
6473 Ok(())
6474 }
6475 }
6476
6477 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
6478 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6479 match self.raw.ordinal() {
6480 1 => unsafe {
6481 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
6482 },
6483 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6484 _ => unsafe { ::core::hint::unreachable_unchecked() },
6485 }
6486 }
6487 }
6488
6489 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
6490 type Natural = crate::natural::DirConnectorRouterRouteResponse;
6491 }
6492
6493 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
6494
6495 #[repr(transparent)]
6497 pub struct DirEntryRouterRouteResponse {
6498 pub(crate) raw: ::fidl_next::RawWireUnion,
6499 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6500 }
6501
6502 impl Drop for DirEntryRouterRouteResponse {
6503 fn drop(&mut self) {
6504 match self.raw.ordinal() {
6505 1 => {
6506 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
6507 }
6508
6509 2 => {
6510 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6511 }
6512
6513 _ => unsafe { ::core::hint::unreachable_unchecked() },
6514 }
6515 }
6516 }
6517
6518 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
6519 type Owned<'de> = DirEntryRouterRouteResponse;
6520
6521 #[inline]
6522 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6523 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6524 ::fidl_next::RawWireUnion::zero_padding(raw);
6525 }
6526 }
6527
6528 pub mod dir_entry_router_route_response {
6529 pub enum Ref<'de> {
6530 DirEntry(&'de crate::wire::DirEntry),
6531
6532 Unavailable(&'de crate::wire::Unit),
6533 }
6534 }
6535
6536 impl DirEntryRouterRouteResponse {
6537 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
6538 match self.raw.ordinal() {
6539 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
6540 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
6541 }),
6542
6543 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
6544 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6545 }),
6546
6547 _ => unsafe { ::core::hint::unreachable_unchecked() },
6548 }
6549 }
6550 }
6551
6552 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
6553 where
6554 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6555 ___D: ::fidl_next::fuchsia::HandleDecoder,
6556 {
6557 fn decode(
6558 mut slot: ::fidl_next::Slot<'_, Self>,
6559 decoder: &mut ___D,
6560 _: (),
6561 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6562 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6563 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6564 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
6565 raw,
6566 decoder,
6567 (),
6568 )?,
6569
6570 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6571 raw,
6572 decoder,
6573 (),
6574 )?,
6575
6576 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6577 }
6578
6579 Ok(())
6580 }
6581 }
6582
6583 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
6584 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6585 match self.raw.ordinal() {
6586 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
6587 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6588 _ => unsafe { ::core::hint::unreachable_unchecked() },
6589 }
6590 }
6591 }
6592
6593 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
6594 type Natural = crate::natural::DirEntryRouterRouteResponse;
6595 }
6596
6597 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
6598
6599 #[repr(C)]
6601 pub struct DirReceiverReceiveRequest<'de> {
6602 pub(crate) table: ::fidl_next::WireTable<'de>,
6603 }
6604
6605 impl<'de> Drop for DirReceiverReceiveRequest<'de> {
6606 fn drop(&mut self) {
6607 let _ = self.table.get(1).map(|envelope| unsafe {
6608 envelope.read_unchecked::<::fidl_next::fuchsia::WireChannel>()
6609 });
6610
6611 let _ = self.table.get(2).map(|envelope| unsafe {
6612 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
6613 });
6614
6615 let _ = self.table.get(3).map(|envelope| unsafe {
6616 envelope.read_unchecked::<::fidl_next::WireString<'de>>()
6617 });
6618 }
6619 }
6620
6621 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest<'static> {
6622 type Owned<'de> = DirReceiverReceiveRequest<'de>;
6623
6624 #[inline]
6625 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6626 ::fidl_next::munge!(let Self { table } = out);
6627 ::fidl_next::WireTable::zero_padding(table);
6628 }
6629 }
6630
6631 unsafe impl<___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest<'static>
6632 where
6633 ___D: ::fidl_next::Decoder + ?Sized,
6634 ___D: ::fidl_next::fuchsia::HandleDecoder,
6635 {
6636 fn decode(
6637 slot: ::fidl_next::Slot<'_, Self>,
6638 decoder: &mut ___D,
6639 _: (),
6640 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6641 ::fidl_next::munge!(let Self { table } = slot);
6642
6643 ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
6644 match ordinal {
6645 0 => unsafe { ::core::hint::unreachable_unchecked() },
6646
6647 1 => {
6648 ::fidl_next::WireEnvelope::decode_as::<
6649 ___D,
6650 ::fidl_next::fuchsia::WireChannel,
6651 >(slot.as_mut(), decoder, ())?;
6652
6653 Ok(())
6654 }
6655
6656 2 => {
6657 ::fidl_next::WireEnvelope::decode_as::<
6658 ___D,
6659 ::fidl_next_fuchsia_io::wire::Flags,
6660 >(slot.as_mut(), decoder, ())?;
6661
6662 Ok(())
6663 }
6664
6665 3 => {
6666 ::fidl_next::WireEnvelope::decode_as::<
6667 ___D,
6668 ::fidl_next::WireString<'static>,
6669 >(slot.as_mut(), decoder, 4095)?;
6670
6671 let value = unsafe {
6672 slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
6673 };
6674
6675 if value.len() > 4095 {
6676 return Err(::fidl_next::DecodeError::VectorTooLong {
6677 size: value.len() as u64,
6678 limit: 4095,
6679 });
6680 }
6681
6682 Ok(())
6683 }
6684
6685 _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
6686 }
6687 })
6688 }
6689 }
6690
6691 impl<'de> DirReceiverReceiveRequest<'de> {
6692 pub fn channel(&self) -> ::core::option::Option<&::fidl_next::fuchsia::WireChannel> {
6693 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
6694 }
6695
6696 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
6697 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
6698 }
6699
6700 pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
6701 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
6702 }
6703 }
6704
6705 impl<'de> ::core::fmt::Debug for DirReceiverReceiveRequest<'de> {
6706 fn fmt(
6707 &self,
6708 f: &mut ::core::fmt::Formatter<'_>,
6709 ) -> ::core::result::Result<(), ::core::fmt::Error> {
6710 f.debug_struct("DirReceiverReceiveRequest")
6711 .field("channel", &self.channel())
6712 .field("flags", &self.flags())
6713 .field("subdir", &self.subdir())
6714 .finish()
6715 }
6716 }
6717
6718 impl<'de> ::fidl_next::IntoNatural for DirReceiverReceiveRequest<'de> {
6719 type Natural = crate::natural::DirReceiverReceiveRequest;
6720 }
6721
6722 impl ::fidl_next::Unconstrained for DirReceiverReceiveRequest<'_> {}
6723
6724 #[repr(transparent)]
6726 pub struct DirectoryRouterRouteResponse {
6727 pub(crate) raw: ::fidl_next::RawWireUnion,
6728 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6729 }
6730
6731 impl Drop for DirectoryRouterRouteResponse {
6732 fn drop(&mut self) {
6733 match self.raw.ordinal() {
6734 1 => {
6735 let _ = unsafe {
6736 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
6737 ::fidl_next_fuchsia_io::Directory,
6738 ::fidl_next::fuchsia::WireChannel,
6739 >>()
6740 };
6741 }
6742
6743 2 => {
6744 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6745 }
6746
6747 _ => unsafe { ::core::hint::unreachable_unchecked() },
6748 }
6749 }
6750 }
6751
6752 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
6753 type Owned<'de> = DirectoryRouterRouteResponse;
6754
6755 #[inline]
6756 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6757 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6758 ::fidl_next::RawWireUnion::zero_padding(raw);
6759 }
6760 }
6761
6762 pub mod directory_router_route_response {
6763 pub enum Ref<'de> {
6764 Directory(
6765 &'de ::fidl_next::ClientEnd<
6766 ::fidl_next_fuchsia_io::Directory,
6767 ::fidl_next::fuchsia::WireChannel,
6768 >,
6769 ),
6770
6771 Unavailable(&'de crate::wire::Unit),
6772 }
6773 }
6774
6775 impl DirectoryRouterRouteResponse {
6776 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
6777 match self.raw.ordinal() {
6778 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
6779 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
6780 ::fidl_next_fuchsia_io::Directory,
6781 ::fidl_next::fuchsia::WireChannel,
6782 >>()
6783 }),
6784
6785 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
6786 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6787 }),
6788
6789 _ => unsafe { ::core::hint::unreachable_unchecked() },
6790 }
6791 }
6792 }
6793
6794 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
6795 where
6796 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6797 ___D: ::fidl_next::fuchsia::HandleDecoder,
6798 {
6799 fn decode(
6800 mut slot: ::fidl_next::Slot<'_, Self>,
6801 decoder: &mut ___D,
6802 _: (),
6803 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6804 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6805 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6806 1 => ::fidl_next::RawWireUnion::decode_as_static::<
6807 ___D,
6808 ::fidl_next::ClientEnd<
6809 ::fidl_next_fuchsia_io::Directory,
6810 ::fidl_next::fuchsia::WireChannel,
6811 >,
6812 >(raw, decoder, ())?,
6813
6814 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
6815 raw,
6816 decoder,
6817 (),
6818 )?,
6819
6820 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6821 }
6822
6823 Ok(())
6824 }
6825 }
6826
6827 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
6828 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6829 match self.raw.ordinal() {
6830 1 => unsafe {
6831 self.raw
6832 .get()
6833 .deref_unchecked::<::fidl_next::ClientEnd<
6834 ::fidl_next_fuchsia_io::Directory,
6835 ::fidl_next::fuchsia::WireChannel,
6836 >>()
6837 .fmt(f)
6838 },
6839 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6840 _ => unsafe { ::core::hint::unreachable_unchecked() },
6841 }
6842 }
6843 }
6844
6845 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
6846 type Natural = crate::natural::DirectoryRouterRouteResponse;
6847 }
6848
6849 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
6850
6851 #[derive(Debug)]
6853 #[repr(C)]
6854 pub struct ProtocolPayload {
6855 pub channel: ::fidl_next::fuchsia::WireChannel,
6856 }
6857
6858 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
6859 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
6860
6861 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
6862
6863 unsafe impl ::fidl_next::Wire for ProtocolPayload {
6864 type Owned<'de> = ProtocolPayload;
6865
6866 #[inline]
6867 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6868 ::fidl_next::munge! {
6869 let Self {
6870
6871 channel,
6872
6873 } = &mut *out_;
6874 }
6875
6876 ::fidl_next::Wire::zero_padding(channel);
6877 }
6878 }
6879
6880 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
6881 where
6882 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6883 ___D: ::fidl_next::fuchsia::HandleDecoder,
6884 {
6885 fn decode(
6886 slot_: ::fidl_next::Slot<'_, Self>,
6887 decoder_: &mut ___D,
6888 _: (),
6889 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6890 ::fidl_next::munge! {
6891 let Self {
6892
6893 mut channel,
6894
6895 } = slot_;
6896 }
6897
6898 let _field = channel.as_mut();
6899
6900 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
6901
6902 Ok(())
6903 }
6904 }
6905
6906 impl ::fidl_next::IntoNatural for ProtocolPayload {
6907 type Natural = crate::natural::ProtocolPayload;
6908 }
6909
6910 impl ::fidl_next::Unconstrained for ProtocolPayload {}
6911}
6912
6913pub mod wire_optional {
6914
6915 pub use fidl_next_common_fuchsia_component_sandbox::wire_optional::*;
6916
6917 #[repr(transparent)]
6918 pub struct Capability<'de> {
6919 pub(crate) raw: ::fidl_next::RawWireUnion,
6920 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6921 }
6922
6923 unsafe impl ::fidl_next::Wire for Capability<'static> {
6924 type Owned<'de> = Capability<'de>;
6925
6926 #[inline]
6927 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6928 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6929 ::fidl_next::RawWireUnion::zero_padding(raw);
6930 }
6931 }
6932
6933 impl<'de> Capability<'de> {
6934 pub fn is_some(&self) -> bool {
6935 self.raw.is_some()
6936 }
6937
6938 pub fn is_none(&self) -> bool {
6939 self.raw.is_none()
6940 }
6941
6942 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
6943 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6944 }
6945
6946 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
6947 if self.is_some() {
6948 Some(crate::wire::Capability {
6949 raw: self.raw,
6950 _phantom: ::core::marker::PhantomData,
6951 })
6952 } else {
6953 None
6954 }
6955 }
6956 }
6957
6958 unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
6959 where
6960 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6961 ___D: ::fidl_next::Decoder,
6962 ___D: ::fidl_next::fuchsia::HandleDecoder,
6963 {
6964 fn decode(
6965 mut slot: ::fidl_next::Slot<'_, Self>,
6966 decoder: &mut ___D,
6967 _: (),
6968 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6969 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6970 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
6971 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
6972 raw,
6973 decoder,
6974 (),
6975 )?,
6976
6977 2 => ::fidl_next::RawWireUnion::decode_as::<
6978 ___D,
6979 ::fidl_next::fuchsia::WireNullableHandle,
6980 >(raw, decoder, ())?,
6981
6982 3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
6983 raw,
6984 decoder,
6985 (),
6986 )?,
6987
6988 4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
6989 raw,
6990 decoder,
6991 (),
6992 )?,
6993
6994 5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
6995 raw,
6996 decoder,
6997 (),
6998 )?,
6999
7000 6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
7001 raw,
7002 decoder,
7003 (),
7004 )?,
7005
7006 7 => ::fidl_next::RawWireUnion::decode_as::<
7007 ___D,
7008 ::fidl_next::ClientEnd<
7009 ::fidl_next_fuchsia_io::Directory,
7010 ::fidl_next::fuchsia::WireChannel,
7011 >,
7012 >(raw, decoder, ())?,
7013
7014 8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
7015 raw,
7016 decoder,
7017 (),
7018 )?,
7019
7020 9 => ::fidl_next::RawWireUnion::decode_as::<
7021 ___D,
7022 ::fidl_next::ClientEnd<
7023 crate::ConnectorRouter,
7024 ::fidl_next::fuchsia::WireChannel,
7025 >,
7026 >(raw, decoder, ())?,
7027
7028 10 => ::fidl_next::RawWireUnion::decode_as::<
7029 ___D,
7030 ::fidl_next::ClientEnd<
7031 crate::DictionaryRouter,
7032 ::fidl_next::fuchsia::WireChannel,
7033 >,
7034 >(raw, decoder, ())?,
7035
7036 11 => ::fidl_next::RawWireUnion::decode_as::<
7037 ___D,
7038 ::fidl_next::ClientEnd<
7039 crate::DirEntryRouter,
7040 ::fidl_next::fuchsia::WireChannel,
7041 >,
7042 >(raw, decoder, ())?,
7043
7044 12 => ::fidl_next::RawWireUnion::decode_as::<
7045 ___D,
7046 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
7047 >(raw, decoder, ())?,
7048
7049 13 => ::fidl_next::RawWireUnion::decode_as::<
7050 ___D,
7051 ::fidl_next::ClientEnd<
7052 crate::DirConnectorRouter,
7053 ::fidl_next::fuchsia::WireChannel,
7054 >,
7055 >(raw, decoder, ())?,
7056
7057 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7058 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
7059 }
7060
7061 Ok(())
7062 }
7063 }
7064
7065 impl<'de> ::core::fmt::Debug for Capability<'de> {
7066 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7067 self.as_ref().fmt(f)
7068 }
7069 }
7070
7071 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
7072 type Natural = ::core::option::Option<crate::natural::Capability>;
7073 }
7074
7075 impl ::fidl_next::Unconstrained for Capability<'static> {}
7076
7077 #[repr(transparent)]
7078 pub struct ConnectorRouterRouteResponse {
7079 pub(crate) raw: ::fidl_next::RawWireUnion,
7080 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7081 }
7082
7083 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
7084 type Owned<'de> = ConnectorRouterRouteResponse;
7085
7086 #[inline]
7087 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7088 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7089 ::fidl_next::RawWireUnion::zero_padding(raw);
7090 }
7091 }
7092
7093 impl ConnectorRouterRouteResponse {
7094 pub fn is_some(&self) -> bool {
7095 self.raw.is_some()
7096 }
7097
7098 pub fn is_none(&self) -> bool {
7099 self.raw.is_none()
7100 }
7101
7102 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
7103 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7104 }
7105
7106 pub fn into_option(
7107 self,
7108 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
7109 if self.is_some() {
7110 Some(crate::wire::ConnectorRouterRouteResponse {
7111 raw: self.raw,
7112 _phantom: ::core::marker::PhantomData,
7113 })
7114 } else {
7115 None
7116 }
7117 }
7118 }
7119
7120 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
7121 where
7122 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7123 ___D: ::fidl_next::fuchsia::HandleDecoder,
7124 {
7125 fn decode(
7126 mut slot: ::fidl_next::Slot<'_, Self>,
7127 decoder: &mut ___D,
7128 _: (),
7129 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7130 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7131 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7132 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
7133 raw,
7134 decoder,
7135 (),
7136 )?,
7137
7138 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
7139 raw,
7140 decoder,
7141 (),
7142 )?,
7143
7144 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7145 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
7146 }
7147
7148 Ok(())
7149 }
7150 }
7151
7152 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
7153 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7154 self.as_ref().fmt(f)
7155 }
7156 }
7157
7158 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
7159 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
7160 }
7161
7162 impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
7163
7164 #[repr(transparent)]
7165 pub struct DataRouterRouteResponse<'de> {
7166 pub(crate) raw: ::fidl_next::RawWireUnion,
7167 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
7168 }
7169
7170 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
7171 type Owned<'de> = DataRouterRouteResponse<'de>;
7172
7173 #[inline]
7174 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7175 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7176 ::fidl_next::RawWireUnion::zero_padding(raw);
7177 }
7178 }
7179
7180 impl<'de> DataRouterRouteResponse<'de> {
7181 pub fn is_some(&self) -> bool {
7182 self.raw.is_some()
7183 }
7184
7185 pub fn is_none(&self) -> bool {
7186 self.raw.is_none()
7187 }
7188
7189 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
7190 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7191 }
7192
7193 pub fn into_option(
7194 self,
7195 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
7196 if self.is_some() {
7197 Some(crate::wire::DataRouterRouteResponse {
7198 raw: self.raw,
7199 _phantom: ::core::marker::PhantomData,
7200 })
7201 } else {
7202 None
7203 }
7204 }
7205 }
7206
7207 unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
7208 where
7209 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7210 ___D: ::fidl_next::Decoder,
7211 ___D: ::fidl_next::fuchsia::HandleDecoder,
7212 {
7213 fn decode(
7214 mut slot: ::fidl_next::Slot<'_, Self>,
7215 decoder: &mut ___D,
7216 _: (),
7217 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7218 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7219 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7220 1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
7221 raw,
7222 decoder,
7223 (),
7224 )?,
7225
7226 2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
7227 raw,
7228 decoder,
7229 (),
7230 )?,
7231
7232 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7233 _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
7234 }
7235
7236 Ok(())
7237 }
7238 }
7239
7240 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
7241 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7242 self.as_ref().fmt(f)
7243 }
7244 }
7245
7246 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
7247 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
7248 }
7249
7250 impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
7251
7252 #[repr(transparent)]
7253 pub struct DictionaryRouterRouteResponse {
7254 pub(crate) raw: ::fidl_next::RawWireUnion,
7255 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7256 }
7257
7258 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
7259 type Owned<'de> = DictionaryRouterRouteResponse;
7260
7261 #[inline]
7262 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7263 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7264 ::fidl_next::RawWireUnion::zero_padding(raw);
7265 }
7266 }
7267
7268 impl DictionaryRouterRouteResponse {
7269 pub fn is_some(&self) -> bool {
7270 self.raw.is_some()
7271 }
7272
7273 pub fn is_none(&self) -> bool {
7274 self.raw.is_none()
7275 }
7276
7277 pub fn as_ref(
7278 &self,
7279 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
7280 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7281 }
7282
7283 pub fn into_option(
7284 self,
7285 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
7286 if self.is_some() {
7287 Some(crate::wire::DictionaryRouterRouteResponse {
7288 raw: self.raw,
7289 _phantom: ::core::marker::PhantomData,
7290 })
7291 } else {
7292 None
7293 }
7294 }
7295 }
7296
7297 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
7298 where
7299 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7300 ___D: ::fidl_next::fuchsia::HandleDecoder,
7301 {
7302 fn decode(
7303 mut slot: ::fidl_next::Slot<'_, Self>,
7304 decoder: &mut ___D,
7305 _: (),
7306 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7307 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7308 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7309 1 => {
7310 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
7311 raw,
7312 decoder,
7313 (),
7314 )?
7315 }
7316
7317 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
7318 raw,
7319 decoder,
7320 (),
7321 )?,
7322
7323 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7324 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
7325 }
7326
7327 Ok(())
7328 }
7329 }
7330
7331 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
7332 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7333 self.as_ref().fmt(f)
7334 }
7335 }
7336
7337 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
7338 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
7339 }
7340
7341 impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
7342
7343 #[repr(transparent)]
7344 pub struct DirConnectorRouterRouteResponse {
7345 pub(crate) raw: ::fidl_next::RawWireUnion,
7346 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7347 }
7348
7349 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
7350 type Owned<'de> = DirConnectorRouterRouteResponse;
7351
7352 #[inline]
7353 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7354 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7355 ::fidl_next::RawWireUnion::zero_padding(raw);
7356 }
7357 }
7358
7359 impl DirConnectorRouterRouteResponse {
7360 pub fn is_some(&self) -> bool {
7361 self.raw.is_some()
7362 }
7363
7364 pub fn is_none(&self) -> bool {
7365 self.raw.is_none()
7366 }
7367
7368 pub fn as_ref(
7369 &self,
7370 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
7371 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7372 }
7373
7374 pub fn into_option(
7375 self,
7376 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
7377 if self.is_some() {
7378 Some(crate::wire::DirConnectorRouterRouteResponse {
7379 raw: self.raw,
7380 _phantom: ::core::marker::PhantomData,
7381 })
7382 } else {
7383 None
7384 }
7385 }
7386 }
7387
7388 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
7389 where
7390 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7391 ___D: ::fidl_next::fuchsia::HandleDecoder,
7392 {
7393 fn decode(
7394 mut slot: ::fidl_next::Slot<'_, Self>,
7395 decoder: &mut ___D,
7396 _: (),
7397 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7398 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7399 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7400 1 => {
7401 ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
7402 raw,
7403 decoder,
7404 (),
7405 )?
7406 }
7407
7408 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
7409 raw,
7410 decoder,
7411 (),
7412 )?,
7413
7414 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7415 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
7416 }
7417
7418 Ok(())
7419 }
7420 }
7421
7422 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
7423 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7424 self.as_ref().fmt(f)
7425 }
7426 }
7427
7428 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
7429 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
7430 }
7431
7432 impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
7433
7434 #[repr(transparent)]
7435 pub struct DirEntryRouterRouteResponse {
7436 pub(crate) raw: ::fidl_next::RawWireUnion,
7437 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7438 }
7439
7440 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
7441 type Owned<'de> = DirEntryRouterRouteResponse;
7442
7443 #[inline]
7444 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7445 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7446 ::fidl_next::RawWireUnion::zero_padding(raw);
7447 }
7448 }
7449
7450 impl DirEntryRouterRouteResponse {
7451 pub fn is_some(&self) -> bool {
7452 self.raw.is_some()
7453 }
7454
7455 pub fn is_none(&self) -> bool {
7456 self.raw.is_none()
7457 }
7458
7459 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
7460 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7461 }
7462
7463 pub fn into_option(
7464 self,
7465 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
7466 if self.is_some() {
7467 Some(crate::wire::DirEntryRouterRouteResponse {
7468 raw: self.raw,
7469 _phantom: ::core::marker::PhantomData,
7470 })
7471 } else {
7472 None
7473 }
7474 }
7475 }
7476
7477 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
7478 where
7479 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7480 ___D: ::fidl_next::fuchsia::HandleDecoder,
7481 {
7482 fn decode(
7483 mut slot: ::fidl_next::Slot<'_, Self>,
7484 decoder: &mut ___D,
7485 _: (),
7486 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7487 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7488 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7489 1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
7490 raw,
7491 decoder,
7492 (),
7493 )?,
7494
7495 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
7496 raw,
7497 decoder,
7498 (),
7499 )?,
7500
7501 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7502 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
7503 }
7504
7505 Ok(())
7506 }
7507 }
7508
7509 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
7510 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7511 self.as_ref().fmt(f)
7512 }
7513 }
7514
7515 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
7516 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
7517 }
7518
7519 impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
7520
7521 #[repr(transparent)]
7522 pub struct DirectoryRouterRouteResponse {
7523 pub(crate) raw: ::fidl_next::RawWireUnion,
7524 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7525 }
7526
7527 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
7528 type Owned<'de> = DirectoryRouterRouteResponse;
7529
7530 #[inline]
7531 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7532 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7533 ::fidl_next::RawWireUnion::zero_padding(raw);
7534 }
7535 }
7536
7537 impl DirectoryRouterRouteResponse {
7538 pub fn is_some(&self) -> bool {
7539 self.raw.is_some()
7540 }
7541
7542 pub fn is_none(&self) -> bool {
7543 self.raw.is_none()
7544 }
7545
7546 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
7547 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7548 }
7549
7550 pub fn into_option(
7551 self,
7552 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
7553 if self.is_some() {
7554 Some(crate::wire::DirectoryRouterRouteResponse {
7555 raw: self.raw,
7556 _phantom: ::core::marker::PhantomData,
7557 })
7558 } else {
7559 None
7560 }
7561 }
7562 }
7563
7564 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
7565 where
7566 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7567 ___D: ::fidl_next::fuchsia::HandleDecoder,
7568 {
7569 fn decode(
7570 mut slot: ::fidl_next::Slot<'_, Self>,
7571 decoder: &mut ___D,
7572 _: (),
7573 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7574 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7575 match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
7576 1 => ::fidl_next::RawWireUnion::decode_as_static::<
7577 ___D,
7578 ::fidl_next::ClientEnd<
7579 ::fidl_next_fuchsia_io::Directory,
7580 ::fidl_next::fuchsia::WireChannel,
7581 >,
7582 >(raw, decoder, ())?,
7583
7584 2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
7585 raw,
7586 decoder,
7587 (),
7588 )?,
7589
7590 0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
7591 _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
7592 }
7593
7594 Ok(())
7595 }
7596 }
7597
7598 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
7599 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7600 self.as_ref().fmt(f)
7601 }
7602 }
7603
7604 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
7605 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
7606 }
7607
7608 impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
7609}
7610
7611pub mod generic {
7612
7613 pub use fidl_next_common_fuchsia_component_sandbox::generic::*;
7614
7615 pub struct DirConnector<T0> {
7616 pub token: T0,
7617 }
7618
7619 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector<T0>
7620 where
7621 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7622 ___E: ::fidl_next::fuchsia::HandleEncoder,
7623 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7624 {
7625 #[inline]
7626 fn encode(
7627 self,
7628 encoder_: &mut ___E,
7629 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
7630 _: (),
7631 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7632 ::fidl_next::munge! {
7633 let crate::wire::DirConnector {
7634
7635 token,
7636
7637 } = out_;
7638 }
7639
7640 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7641
7642 Ok(())
7643 }
7644 }
7645
7646 pub struct DictionaryRef<T0> {
7647 pub token: T0,
7648 }
7649
7650 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef<T0>
7651 where
7652 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7653 ___E: ::fidl_next::fuchsia::HandleEncoder,
7654 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7655 {
7656 #[inline]
7657 fn encode(
7658 self,
7659 encoder_: &mut ___E,
7660 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
7661 _: (),
7662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7663 ::fidl_next::munge! {
7664 let crate::wire::DictionaryRef {
7665
7666 token,
7667
7668 } = out_;
7669 }
7670
7671 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7672
7673 Ok(())
7674 }
7675 }
7676
7677 pub struct Connector<T0> {
7678 pub token: T0,
7679 }
7680
7681 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector<T0>
7682 where
7683 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7684 ___E: ::fidl_next::fuchsia::HandleEncoder,
7685 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7686 {
7687 #[inline]
7688 fn encode(
7689 self,
7690 encoder_: &mut ___E,
7691 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
7692 _: (),
7693 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7694 ::fidl_next::munge! {
7695 let crate::wire::Connector {
7696
7697 token,
7698
7699 } = out_;
7700 }
7701
7702 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7703
7704 Ok(())
7705 }
7706 }
7707
7708 pub struct DirEntry<T0> {
7709 pub token: T0,
7710 }
7711
7712 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry<T0>
7713 where
7714 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7715 ___E: ::fidl_next::fuchsia::HandleEncoder,
7716 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
7717 {
7718 #[inline]
7719 fn encode(
7720 self,
7721 encoder_: &mut ___E,
7722 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
7723 _: (),
7724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7725 ::fidl_next::munge! {
7726 let crate::wire::DirEntry {
7727
7728 token,
7729
7730 } = out_;
7731 }
7732
7733 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
7734
7735 Ok(())
7736 }
7737 }
7738
7739 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
7740 pub id: T0,
7741
7742 pub receiver: T1,
7743 }
7744
7745 unsafe impl<___E, T0, T1>
7746 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
7747 for CapabilityStoreConnectorCreateRequest<T0, T1>
7748 where
7749 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7750 ___E: ::fidl_next::fuchsia::HandleEncoder,
7751 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7752 T1: ::fidl_next::Encode<
7753 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
7754 ___E,
7755 >,
7756 {
7757 #[inline]
7758 fn encode(
7759 self,
7760 encoder_: &mut ___E,
7761 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
7762 _: (),
7763 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7764 ::fidl_next::munge! {
7765 let crate::wire::CapabilityStoreConnectorCreateRequest {
7766
7767 id,
7768 receiver,
7769
7770 } = out_;
7771 }
7772
7773 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7774
7775 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
7776
7777 Ok(())
7778 }
7779 }
7780
7781 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
7782 pub id: T0,
7783
7784 pub server_end: T1,
7785 }
7786
7787 unsafe impl<___E, T0, T1>
7788 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
7789 for CapabilityStoreConnectorOpenRequest<T0, T1>
7790 where
7791 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7792 ___E: ::fidl_next::fuchsia::HandleEncoder,
7793 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7794 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7795 {
7796 #[inline]
7797 fn encode(
7798 self,
7799 encoder_: &mut ___E,
7800 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
7801 _: (),
7802 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7803 ::fidl_next::munge! {
7804 let crate::wire::CapabilityStoreConnectorOpenRequest {
7805
7806 id,
7807 server_end,
7808
7809 } = out_;
7810 }
7811
7812 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7813
7814 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7815
7816 Ok(())
7817 }
7818 }
7819
7820 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
7821 pub id: T0,
7822
7823 pub receiver: T1,
7824 }
7825
7826 unsafe impl<___E, T0, T1>
7827 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
7828 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
7829 where
7830 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7831 ___E: ::fidl_next::fuchsia::HandleEncoder,
7832 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7833 T1: ::fidl_next::Encode<
7834 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
7835 ___E,
7836 >,
7837 {
7838 #[inline]
7839 fn encode(
7840 self,
7841 encoder_: &mut ___E,
7842 out_: &mut ::core::mem::MaybeUninit<
7843 crate::wire::CapabilityStoreDirConnectorCreateRequest,
7844 >,
7845 _: (),
7846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7847 ::fidl_next::munge! {
7848 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
7849
7850 id,
7851 receiver,
7852
7853 } = out_;
7854 }
7855
7856 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7857
7858 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
7859
7860 Ok(())
7861 }
7862 }
7863
7864 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
7865 pub id: T0,
7866
7867 pub client_end: T1,
7868 }
7869
7870 unsafe impl<___E, T0, T1>
7871 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
7872 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
7873 where
7874 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7875 ___E: ::fidl_next::fuchsia::HandleEncoder,
7876 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7877 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7878 {
7879 #[inline]
7880 fn encode(
7881 self,
7882 encoder_: &mut ___E,
7883 out_: &mut ::core::mem::MaybeUninit<
7884 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
7885 >,
7886 _: (),
7887 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7888 ::fidl_next::munge! {
7889 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
7890
7891 id,
7892 client_end,
7893
7894 } = out_;
7895 }
7896
7897 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7898
7899 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
7900
7901 Ok(())
7902 }
7903 }
7904
7905 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
7906 pub id: T0,
7907
7908 pub server_end: T1,
7909 }
7910
7911 unsafe impl<___E, T0, T1>
7912 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
7913 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
7914 where
7915 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7916 ___E: ::fidl_next::fuchsia::HandleEncoder,
7917 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7918 T1: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
7919 {
7920 #[inline]
7921 fn encode(
7922 self,
7923 encoder_: &mut ___E,
7924 out_: &mut ::core::mem::MaybeUninit<
7925 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
7926 >,
7927 _: (),
7928 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7929 ::fidl_next::munge! {
7930 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
7931
7932 id,
7933 server_end,
7934
7935 } = out_;
7936 }
7937
7938 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7939
7940 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
7941
7942 Ok(())
7943 }
7944 }
7945
7946 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
7947 pub id: T0,
7948
7949 pub iterator: T1,
7950 }
7951
7952 unsafe impl<___E, T0, T1>
7953 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
7954 for CapabilityStoreDictionaryKeysRequest<T0, T1>
7955 where
7956 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7957 ___E: ::fidl_next::fuchsia::HandleEncoder,
7958 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
7959 T1: ::fidl_next::Encode<
7960 ::fidl_next::ServerEnd<
7961 crate::DictionaryKeysIterator,
7962 ::fidl_next::fuchsia::WireChannel,
7963 >,
7964 ___E,
7965 >,
7966 {
7967 #[inline]
7968 fn encode(
7969 self,
7970 encoder_: &mut ___E,
7971 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
7972 _: (),
7973 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7974 ::fidl_next::munge! {
7975 let crate::wire::CapabilityStoreDictionaryKeysRequest {
7976
7977 id,
7978 iterator,
7979
7980 } = out_;
7981 }
7982
7983 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
7984
7985 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7986
7987 Ok(())
7988 }
7989 }
7990
7991 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
7992 pub id: T0,
7993
7994 pub iterator: T1,
7995 }
7996
7997 unsafe impl<___E, T0, T1>
7998 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
7999 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
8000 where
8001 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8002 ___E: ::fidl_next::fuchsia::HandleEncoder,
8003 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
8004 T1: ::fidl_next::Encode<
8005 ::fidl_next::ServerEnd<
8006 crate::DictionaryEnumerateIterator,
8007 ::fidl_next::fuchsia::WireChannel,
8008 >,
8009 ___E,
8010 >,
8011 {
8012 #[inline]
8013 fn encode(
8014 self,
8015 encoder_: &mut ___E,
8016 out_: &mut ::core::mem::MaybeUninit<
8017 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
8018 >,
8019 _: (),
8020 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8021 ::fidl_next::munge! {
8022 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
8023
8024 id,
8025 iterator,
8026
8027 } = out_;
8028 }
8029
8030 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8031
8032 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8033
8034 Ok(())
8035 }
8036 }
8037
8038 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
8039 pub id: T0,
8040
8041 pub iterator: T1,
8042 }
8043
8044 unsafe impl<___E, T0, T1>
8045 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
8046 for CapabilityStoreDictionaryDrainRequest<T0, T1>
8047 where
8048 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8049 ___E: ::fidl_next::fuchsia::HandleEncoder,
8050 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
8051 T1: ::fidl_next::Encode<
8052 ::fidl_next::ServerEnd<
8053 crate::DictionaryDrainIterator,
8054 ::fidl_next::fuchsia::WireOptionalChannel,
8055 >,
8056 ___E,
8057 >,
8058 {
8059 #[inline]
8060 fn encode(
8061 self,
8062 encoder_: &mut ___E,
8063 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
8064 _: (),
8065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8066 ::fidl_next::munge! {
8067 let crate::wire::CapabilityStoreDictionaryDrainRequest {
8068
8069 id,
8070 iterator,
8071
8072 } = out_;
8073 }
8074
8075 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8076
8077 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8078
8079 Ok(())
8080 }
8081 }
8082
8083 pub struct CapabilityStoreCreateServiceAggregateRequest<T0> {
8084 pub sources: T0,
8085 }
8086
8087 unsafe impl<___E, T0>
8088 ::fidl_next::Encode<
8089 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
8090 ___E,
8091 > for CapabilityStoreCreateServiceAggregateRequest<T0>
8092 where
8093 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8094 ___E: ::fidl_next::Encoder,
8095 ___E: ::fidl_next::fuchsia::HandleEncoder,
8096 T0: ::fidl_next::Encode<
8097 ::fidl_next::WireVector<'static, crate::wire::AggregateSource<'static>>,
8098 ___E,
8099 >,
8100 {
8101 #[inline]
8102 fn encode(
8103 self,
8104 encoder_: &mut ___E,
8105 out_: &mut ::core::mem::MaybeUninit<
8106 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
8107 >,
8108 _: (),
8109 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8110 ::fidl_next::munge! {
8111 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
8112
8113 sources,
8114
8115 } = out_;
8116 }
8117
8118 ::fidl_next::Encode::encode(self.sources, encoder_, sources, (4294967295, ()))?;
8119
8120 Ok(())
8121 }
8122 }
8123
8124 pub struct CapabilityStoreCreateServiceAggregateResponse<T0> {
8125 pub aggregate_dir_connector: T0,
8126 }
8127
8128 unsafe impl<___E, T0>
8129 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
8130 for CapabilityStoreCreateServiceAggregateResponse<T0>
8131 where
8132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8133 ___E: ::fidl_next::fuchsia::HandleEncoder,
8134 T0: ::fidl_next::Encode<crate::wire::DirConnector, ___E>,
8135 {
8136 #[inline]
8137 fn encode(
8138 self,
8139 encoder_: &mut ___E,
8140 out_: &mut ::core::mem::MaybeUninit<
8141 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
8142 >,
8143 _: (),
8144 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8145 ::fidl_next::munge! {
8146 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
8147
8148 aggregate_dir_connector,
8149
8150 } = out_;
8151 }
8152
8153 ::fidl_next::Encode::encode(
8154 self.aggregate_dir_connector,
8155 encoder_,
8156 aggregate_dir_connector,
8157 (),
8158 )?;
8159
8160 Ok(())
8161 }
8162 }
8163
8164 pub struct CapabilityStoreExportResponse<T0> {
8165 pub capability: T0,
8166 }
8167
8168 unsafe impl<___E, T0>
8169 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
8170 for CapabilityStoreExportResponse<T0>
8171 where
8172 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8173 ___E: ::fidl_next::Encoder,
8174 ___E: ::fidl_next::fuchsia::HandleEncoder,
8175 T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
8176 {
8177 #[inline]
8178 fn encode(
8179 self,
8180 encoder_: &mut ___E,
8181 out_: &mut ::core::mem::MaybeUninit<
8182 crate::wire::CapabilityStoreExportResponse<'static>,
8183 >,
8184 _: (),
8185 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8186 ::fidl_next::munge! {
8187 let crate::wire::CapabilityStoreExportResponse {
8188
8189 capability,
8190
8191 } = out_;
8192 }
8193
8194 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
8195
8196 Ok(())
8197 }
8198 }
8199
8200 pub struct CapabilityStoreImportRequest<T0, T1> {
8201 pub id: T0,
8202
8203 pub capability: T1,
8204 }
8205
8206 unsafe impl<___E, T0, T1>
8207 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
8208 for CapabilityStoreImportRequest<T0, T1>
8209 where
8210 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8211 ___E: ::fidl_next::Encoder,
8212 ___E: ::fidl_next::fuchsia::HandleEncoder,
8213 T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
8214 T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
8215 {
8216 #[inline]
8217 fn encode(
8218 self,
8219 encoder_: &mut ___E,
8220 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
8221 _: (),
8222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8223 ::fidl_next::munge! {
8224 let crate::wire::CapabilityStoreImportRequest {
8225
8226 id,
8227 capability,
8228
8229 } = out_;
8230 }
8231
8232 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8233
8234 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
8235
8236 Ok(())
8237 }
8238 }
8239
8240 pub struct InstanceToken<T0> {
8241 pub token: T0,
8242 }
8243
8244 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken<T0>
8245 where
8246 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8247 ___E: ::fidl_next::fuchsia::HandleEncoder,
8248 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireEventPair, ___E>,
8249 {
8250 #[inline]
8251 fn encode(
8252 self,
8253 encoder_: &mut ___E,
8254 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
8255 _: (),
8256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8257 ::fidl_next::munge! {
8258 let crate::wire::InstanceToken {
8259
8260 token,
8261
8262 } = out_;
8263 }
8264
8265 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8266
8267 Ok(())
8268 }
8269 }
8270
8271 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
8272 pub items: T0,
8273
8274 pub end_id: T1,
8275 }
8276
8277 unsafe impl<___E, T0, T1>
8278 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
8279 for DictionaryDrainIteratorGetNextResponse<T0, T1>
8280 where
8281 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8282 ___E: ::fidl_next::Encoder,
8283 ___E: ::fidl_next::fuchsia::HandleEncoder,
8284 T0: ::fidl_next::Encode<
8285 ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
8286 ___E,
8287 >,
8288 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
8289 {
8290 #[inline]
8291 fn encode(
8292 self,
8293 encoder_: &mut ___E,
8294 out_: &mut ::core::mem::MaybeUninit<
8295 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
8296 >,
8297 _: (),
8298 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8299 ::fidl_next::munge! {
8300 let crate::wire::DictionaryDrainIteratorGetNextResponse {
8301
8302 items,
8303 end_id,
8304
8305 } = out_;
8306 }
8307
8308 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
8309
8310 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
8311
8312 Ok(())
8313 }
8314 }
8315
8316 pub struct DictionaryOptionalItem<T0, T1> {
8317 pub key: T0,
8318
8319 pub value: T1,
8320 }
8321
8322 unsafe impl<___E, T0, T1>
8323 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
8324 for DictionaryOptionalItem<T0, T1>
8325 where
8326 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8327 ___E: ::fidl_next::Encoder,
8328 ___E: ::fidl_next::fuchsia::HandleEncoder,
8329 T0: ::fidl_next::Encode<::fidl_next::WireString<'static>, ___E>,
8330 T1: ::fidl_next::Encode<
8331 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
8332 ___E,
8333 >,
8334 {
8335 #[inline]
8336 fn encode(
8337 self,
8338 encoder_: &mut ___E,
8339 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
8340 _: (),
8341 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8342 ::fidl_next::munge! {
8343 let crate::wire::DictionaryOptionalItem {
8344
8345 key,
8346 value,
8347
8348 } = out_;
8349 }
8350
8351 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
8352
8353 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
8354
8355 Ok(())
8356 }
8357 }
8358
8359 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
8360 pub items: T0,
8361
8362 pub end_id: T1,
8363 }
8364
8365 unsafe impl<___E, T0, T1>
8366 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
8367 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
8368 where
8369 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8370 ___E: ::fidl_next::Encoder,
8371 ___E: ::fidl_next::fuchsia::HandleEncoder,
8372 T0: ::fidl_next::Encode<
8373 ::fidl_next::WireVector<'static, crate::wire::DictionaryOptionalItem<'static>>,
8374 ___E,
8375 >,
8376 T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
8377 {
8378 #[inline]
8379 fn encode(
8380 self,
8381 encoder_: &mut ___E,
8382 out_: &mut ::core::mem::MaybeUninit<
8383 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
8384 >,
8385 _: (),
8386 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8387 ::fidl_next::munge! {
8388 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
8389
8390 items,
8391 end_id,
8392
8393 } = out_;
8394 }
8395
8396 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
8397
8398 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
8399
8400 Ok(())
8401 }
8402 }
8403
8404 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
8405 pub keys: T0,
8406 }
8407
8408 unsafe impl<___E, T0>
8409 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
8410 for DictionaryKeysIteratorGetNextResponse<T0>
8411 where
8412 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8413 ___E: ::fidl_next::Encoder,
8414 ___E: ::fidl_next::fuchsia::HandleEncoder,
8415 T0: ::fidl_next::Encode<
8416 ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
8417 ___E,
8418 >,
8419 {
8420 #[inline]
8421 fn encode(
8422 self,
8423 encoder_: &mut ___E,
8424 out_: &mut ::core::mem::MaybeUninit<
8425 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
8426 >,
8427 _: (),
8428 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8429 ::fidl_next::munge! {
8430 let crate::wire::DictionaryKeysIteratorGetNextResponse {
8431
8432 keys,
8433
8434 } = out_;
8435 }
8436
8437 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
8438
8439 Ok(())
8440 }
8441 }
8442
8443 pub struct ProtocolPayload<T0> {
8444 pub channel: T0,
8445 }
8446
8447 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
8448 for ProtocolPayload<T0>
8449 where
8450 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8451 ___E: ::fidl_next::fuchsia::HandleEncoder,
8452 T0: ::fidl_next::Encode<::fidl_next::fuchsia::WireChannel, ___E>,
8453 {
8454 #[inline]
8455 fn encode(
8456 self,
8457 encoder_: &mut ___E,
8458 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
8459 _: (),
8460 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8461 ::fidl_next::munge! {
8462 let crate::wire::ProtocolPayload {
8463
8464 channel,
8465
8466 } = out_;
8467 }
8468
8469 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
8470
8471 Ok(())
8472 }
8473 }
8474}
8475
8476pub use self::natural::*;
8477
8478#[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"]
8480#[derive(PartialEq, Debug)]
8481pub struct CapabilityStore;
8482
8483impl ::fidl_next::Discoverable for CapabilityStore {
8484 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
8485}
8486
8487#[cfg(target_os = "fuchsia")]
8488impl ::fidl_next::HasTransport for CapabilityStore {
8489 type Transport = ::fidl_next::fuchsia::zx::Channel;
8490}
8491
8492pub mod capability_store {
8493 pub mod prelude {
8494 pub use crate::{
8495 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
8496 capability_store,
8497 };
8498
8499 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
8500
8501 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
8502
8503 pub use crate::natural::CapabilityStoreCreateServiceAggregateRequest;
8504
8505 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
8506
8507 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
8508
8509 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
8510
8511 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
8512
8513 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
8514
8515 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
8516
8517 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
8518
8519 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
8520
8521 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
8522
8523 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
8524
8525 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
8526
8527 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
8528
8529 pub use crate::natural::CapabilityStoreDropRequest;
8530
8531 pub use crate::natural::CapabilityStoreDuplicateRequest;
8532
8533 pub use crate::natural::CapabilityStoreError;
8534
8535 pub use crate::natural::CapabilityStoreExportRequest;
8536
8537 pub use crate::natural::CapabilityStoreImportRequest;
8538
8539 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
8540
8541 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
8542
8543 pub use crate::natural::CapabilityStoreCreateServiceAggregateResponse;
8544
8545 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
8546
8547 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
8548
8549 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
8550
8551 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
8552
8553 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
8554
8555 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
8556
8557 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
8558
8559 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
8560
8561 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
8562
8563 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
8564
8565 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
8566
8567 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
8568
8569 pub use crate::natural::CapabilityStoreDropResponse;
8570
8571 pub use crate::natural::CapabilityStoreDuplicateResponse;
8572
8573 pub use crate::natural::CapabilityStoreExportResponse;
8574
8575 pub use crate::natural::CapabilityStoreImportResponse;
8576 }
8577
8578 pub struct Duplicate;
8579
8580 impl ::fidl_next::Method for Duplicate {
8581 const ORDINAL: u64 = 6727592627741008260;
8582 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8583 ::fidl_next::protocol::Flexibility::Flexible;
8584
8585 type Protocol = crate::CapabilityStore;
8586
8587 type Request = crate::wire::CapabilityStoreDuplicateRequest;
8588 }
8589
8590 impl ::fidl_next::TwoWayMethod for Duplicate {
8591 type Response = ::fidl_next::WireFlexibleResult<
8592 'static,
8593 crate::wire::CapabilityStoreDuplicateResponse,
8594 crate::wire::CapabilityStoreError,
8595 >;
8596 }
8597
8598 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
8599 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8600
8601 fn respond(response: ___R) -> Self::Output {
8602 ::fidl_next::FlexibleResult::Ok(response)
8603 }
8604 }
8605
8606 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
8607 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8608
8609 fn respond_err(response: ___R) -> Self::Output {
8610 ::fidl_next::FlexibleResult::Err(response)
8611 }
8612 }
8613
8614 pub struct Drop;
8615
8616 impl ::fidl_next::Method for Drop {
8617 const ORDINAL: u64 = 753328233834620249;
8618 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8619 ::fidl_next::protocol::Flexibility::Flexible;
8620
8621 type Protocol = crate::CapabilityStore;
8622
8623 type Request = crate::wire::CapabilityStoreDropRequest;
8624 }
8625
8626 impl ::fidl_next::TwoWayMethod for Drop {
8627 type Response = ::fidl_next::WireFlexibleResult<
8628 'static,
8629 crate::wire::CapabilityStoreDropResponse,
8630 crate::wire::CapabilityStoreError,
8631 >;
8632 }
8633
8634 impl<___R> ::fidl_next::Respond<___R> for Drop {
8635 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8636
8637 fn respond(response: ___R) -> Self::Output {
8638 ::fidl_next::FlexibleResult::Ok(response)
8639 }
8640 }
8641
8642 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
8643 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8644
8645 fn respond_err(response: ___R) -> Self::Output {
8646 ::fidl_next::FlexibleResult::Err(response)
8647 }
8648 }
8649
8650 pub struct Export;
8651
8652 impl ::fidl_next::Method for Export {
8653 const ORDINAL: u64 = 226159162093533951;
8654 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8655 ::fidl_next::protocol::Flexibility::Flexible;
8656
8657 type Protocol = crate::CapabilityStore;
8658
8659 type Request = crate::wire::CapabilityStoreExportRequest;
8660 }
8661
8662 impl ::fidl_next::TwoWayMethod for Export {
8663 type Response = ::fidl_next::WireFlexibleResult<
8664 'static,
8665 crate::wire::CapabilityStoreExportResponse<'static>,
8666 crate::wire::CapabilityStoreError,
8667 >;
8668 }
8669
8670 impl<___R> ::fidl_next::Respond<___R> for Export {
8671 type Output = ::fidl_next::FlexibleResult<
8672 crate::generic::CapabilityStoreExportResponse<___R>,
8673 ::fidl_next::util::Never,
8674 >;
8675
8676 fn respond(response: ___R) -> Self::Output {
8677 ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
8678 capability: response,
8679 })
8680 }
8681 }
8682
8683 impl<___R> ::fidl_next::RespondErr<___R> for Export {
8684 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8685
8686 fn respond_err(response: ___R) -> Self::Output {
8687 ::fidl_next::FlexibleResult::Err(response)
8688 }
8689 }
8690
8691 pub struct Import;
8692
8693 impl ::fidl_next::Method for Import {
8694 const ORDINAL: u64 = 2276030276116435867;
8695 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8696 ::fidl_next::protocol::Flexibility::Flexible;
8697
8698 type Protocol = crate::CapabilityStore;
8699
8700 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
8701 }
8702
8703 impl ::fidl_next::TwoWayMethod for Import {
8704 type Response = ::fidl_next::WireFlexibleResult<
8705 'static,
8706 crate::wire::CapabilityStoreImportResponse,
8707 crate::wire::CapabilityStoreError,
8708 >;
8709 }
8710
8711 impl<___R> ::fidl_next::Respond<___R> for Import {
8712 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8713
8714 fn respond(response: ___R) -> Self::Output {
8715 ::fidl_next::FlexibleResult::Ok(response)
8716 }
8717 }
8718
8719 impl<___R> ::fidl_next::RespondErr<___R> for Import {
8720 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8721
8722 fn respond_err(response: ___R) -> Self::Output {
8723 ::fidl_next::FlexibleResult::Err(response)
8724 }
8725 }
8726
8727 pub struct ConnectorCreate;
8728
8729 impl ::fidl_next::Method for ConnectorCreate {
8730 const ORDINAL: u64 = 2979461408102095909;
8731 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8732 ::fidl_next::protocol::Flexibility::Flexible;
8733
8734 type Protocol = crate::CapabilityStore;
8735
8736 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
8737 }
8738
8739 impl ::fidl_next::TwoWayMethod for ConnectorCreate {
8740 type Response = ::fidl_next::WireFlexibleResult<
8741 'static,
8742 crate::wire::CapabilityStoreConnectorCreateResponse,
8743 crate::wire::CapabilityStoreError,
8744 >;
8745 }
8746
8747 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
8748 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8749
8750 fn respond(response: ___R) -> Self::Output {
8751 ::fidl_next::FlexibleResult::Ok(response)
8752 }
8753 }
8754
8755 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
8756 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8757
8758 fn respond_err(response: ___R) -> Self::Output {
8759 ::fidl_next::FlexibleResult::Err(response)
8760 }
8761 }
8762
8763 pub struct ConnectorOpen;
8764
8765 impl ::fidl_next::Method for ConnectorOpen {
8766 const ORDINAL: u64 = 6016362336453278623;
8767 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8768 ::fidl_next::protocol::Flexibility::Flexible;
8769
8770 type Protocol = crate::CapabilityStore;
8771
8772 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
8773 }
8774
8775 impl ::fidl_next::TwoWayMethod for ConnectorOpen {
8776 type Response = ::fidl_next::WireFlexibleResult<
8777 'static,
8778 crate::wire::CapabilityStoreConnectorOpenResponse,
8779 crate::wire::CapabilityStoreError,
8780 >;
8781 }
8782
8783 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
8784 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8785
8786 fn respond(response: ___R) -> Self::Output {
8787 ::fidl_next::FlexibleResult::Ok(response)
8788 }
8789 }
8790
8791 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
8792 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8793
8794 fn respond_err(response: ___R) -> Self::Output {
8795 ::fidl_next::FlexibleResult::Err(response)
8796 }
8797 }
8798
8799 pub struct DirConnectorCreate;
8800
8801 impl ::fidl_next::Method for DirConnectorCreate {
8802 const ORDINAL: u64 = 1756747594275428795;
8803 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8804 ::fidl_next::protocol::Flexibility::Flexible;
8805
8806 type Protocol = crate::CapabilityStore;
8807
8808 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
8809 }
8810
8811 impl ::fidl_next::TwoWayMethod for DirConnectorCreate {
8812 type Response = ::fidl_next::WireFlexibleResult<
8813 'static,
8814 crate::wire::CapabilityStoreDirConnectorCreateResponse,
8815 crate::wire::CapabilityStoreError,
8816 >;
8817 }
8818
8819 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
8820 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8821
8822 fn respond(response: ___R) -> Self::Output {
8823 ::fidl_next::FlexibleResult::Ok(response)
8824 }
8825 }
8826
8827 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
8828 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8829
8830 fn respond_err(response: ___R) -> Self::Output {
8831 ::fidl_next::FlexibleResult::Err(response)
8832 }
8833 }
8834
8835 pub struct DirConnectorOpen;
8836
8837 impl ::fidl_next::Method for DirConnectorOpen {
8838 const ORDINAL: u64 = 6219704004220369153;
8839 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8840 ::fidl_next::protocol::Flexibility::Flexible;
8841
8842 type Protocol = crate::CapabilityStore;
8843
8844 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>;
8845 }
8846
8847 impl ::fidl_next::TwoWayMethod for DirConnectorOpen {
8848 type Response = ::fidl_next::WireFlexibleResult<
8849 'static,
8850 crate::wire::CapabilityStoreDirConnectorOpenResponse,
8851 crate::wire::CapabilityStoreError,
8852 >;
8853 }
8854
8855 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
8856 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8857
8858 fn respond(response: ___R) -> Self::Output {
8859 ::fidl_next::FlexibleResult::Ok(response)
8860 }
8861 }
8862
8863 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
8864 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8865
8866 fn respond_err(response: ___R) -> Self::Output {
8867 ::fidl_next::FlexibleResult::Err(response)
8868 }
8869 }
8870
8871 pub struct DictionaryCreate;
8872
8873 impl ::fidl_next::Method for DictionaryCreate {
8874 const ORDINAL: u64 = 7608770958894948499;
8875 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8876 ::fidl_next::protocol::Flexibility::Flexible;
8877
8878 type Protocol = crate::CapabilityStore;
8879
8880 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
8881 }
8882
8883 impl ::fidl_next::TwoWayMethod for DictionaryCreate {
8884 type Response = ::fidl_next::WireFlexibleResult<
8885 'static,
8886 crate::wire::CapabilityStoreDictionaryCreateResponse,
8887 crate::wire::CapabilityStoreError,
8888 >;
8889 }
8890
8891 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
8892 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8893
8894 fn respond(response: ___R) -> Self::Output {
8895 ::fidl_next::FlexibleResult::Ok(response)
8896 }
8897 }
8898
8899 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
8900 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8901
8902 fn respond_err(response: ___R) -> Self::Output {
8903 ::fidl_next::FlexibleResult::Err(response)
8904 }
8905 }
8906
8907 pub struct DictionaryLegacyImport;
8908
8909 impl ::fidl_next::Method for DictionaryLegacyImport {
8910 const ORDINAL: u64 = 8285893703432012383;
8911 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8912 ::fidl_next::protocol::Flexibility::Flexible;
8913
8914 type Protocol = crate::CapabilityStore;
8915
8916 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
8917 }
8918
8919 impl ::fidl_next::TwoWayMethod for DictionaryLegacyImport {
8920 type Response = ::fidl_next::WireFlexibleResult<
8921 'static,
8922 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
8923 crate::wire::CapabilityStoreError,
8924 >;
8925 }
8926
8927 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
8928 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8929
8930 fn respond(response: ___R) -> Self::Output {
8931 ::fidl_next::FlexibleResult::Ok(response)
8932 }
8933 }
8934
8935 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
8936 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8937
8938 fn respond_err(response: ___R) -> Self::Output {
8939 ::fidl_next::FlexibleResult::Err(response)
8940 }
8941 }
8942
8943 pub struct DictionaryLegacyExport;
8944
8945 impl ::fidl_next::Method for DictionaryLegacyExport {
8946 const ORDINAL: u64 = 4647175832683306445;
8947 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8948 ::fidl_next::protocol::Flexibility::Flexible;
8949
8950 type Protocol = crate::CapabilityStore;
8951
8952 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
8953 }
8954
8955 impl ::fidl_next::TwoWayMethod for DictionaryLegacyExport {
8956 type Response = ::fidl_next::WireFlexibleResult<
8957 'static,
8958 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
8959 crate::wire::CapabilityStoreError,
8960 >;
8961 }
8962
8963 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
8964 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8965
8966 fn respond(response: ___R) -> Self::Output {
8967 ::fidl_next::FlexibleResult::Ok(response)
8968 }
8969 }
8970
8971 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
8972 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8973
8974 fn respond_err(response: ___R) -> Self::Output {
8975 ::fidl_next::FlexibleResult::Err(response)
8976 }
8977 }
8978
8979 pub struct DictionaryInsert;
8980
8981 impl ::fidl_next::Method for DictionaryInsert {
8982 const ORDINAL: u64 = 8575443262986538023;
8983 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8984 ::fidl_next::protocol::Flexibility::Flexible;
8985
8986 type Protocol = crate::CapabilityStore;
8987
8988 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
8989 }
8990
8991 impl ::fidl_next::TwoWayMethod for DictionaryInsert {
8992 type Response = ::fidl_next::WireFlexibleResult<
8993 'static,
8994 crate::wire::CapabilityStoreDictionaryInsertResponse,
8995 crate::wire::CapabilityStoreError,
8996 >;
8997 }
8998
8999 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
9000 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9001
9002 fn respond(response: ___R) -> Self::Output {
9003 ::fidl_next::FlexibleResult::Ok(response)
9004 }
9005 }
9006
9007 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
9008 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9009
9010 fn respond_err(response: ___R) -> Self::Output {
9011 ::fidl_next::FlexibleResult::Err(response)
9012 }
9013 }
9014
9015 pub struct DictionaryGet;
9016
9017 impl ::fidl_next::Method for DictionaryGet {
9018 const ORDINAL: u64 = 5592951026866236882;
9019 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9020 ::fidl_next::protocol::Flexibility::Flexible;
9021
9022 type Protocol = crate::CapabilityStore;
9023
9024 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
9025 }
9026
9027 impl ::fidl_next::TwoWayMethod for DictionaryGet {
9028 type Response = ::fidl_next::WireFlexibleResult<
9029 'static,
9030 crate::wire::CapabilityStoreDictionaryGetResponse,
9031 crate::wire::CapabilityStoreError,
9032 >;
9033 }
9034
9035 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
9036 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9037
9038 fn respond(response: ___R) -> Self::Output {
9039 ::fidl_next::FlexibleResult::Ok(response)
9040 }
9041 }
9042
9043 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
9044 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9045
9046 fn respond_err(response: ___R) -> Self::Output {
9047 ::fidl_next::FlexibleResult::Err(response)
9048 }
9049 }
9050
9051 pub struct DictionaryRemove;
9052
9053 impl ::fidl_next::Method for DictionaryRemove {
9054 const ORDINAL: u64 = 343892214579320051;
9055 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9056 ::fidl_next::protocol::Flexibility::Flexible;
9057
9058 type Protocol = crate::CapabilityStore;
9059
9060 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
9061 }
9062
9063 impl ::fidl_next::TwoWayMethod for DictionaryRemove {
9064 type Response = ::fidl_next::WireFlexibleResult<
9065 'static,
9066 crate::wire::CapabilityStoreDictionaryRemoveResponse,
9067 crate::wire::CapabilityStoreError,
9068 >;
9069 }
9070
9071 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
9072 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9073
9074 fn respond(response: ___R) -> Self::Output {
9075 ::fidl_next::FlexibleResult::Ok(response)
9076 }
9077 }
9078
9079 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
9080 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9081
9082 fn respond_err(response: ___R) -> Self::Output {
9083 ::fidl_next::FlexibleResult::Err(response)
9084 }
9085 }
9086
9087 pub struct DictionaryCopy;
9088
9089 impl ::fidl_next::Method for DictionaryCopy {
9090 const ORDINAL: u64 = 3977783339739362383;
9091 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9092 ::fidl_next::protocol::Flexibility::Flexible;
9093
9094 type Protocol = crate::CapabilityStore;
9095
9096 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
9097 }
9098
9099 impl ::fidl_next::TwoWayMethod for DictionaryCopy {
9100 type Response = ::fidl_next::WireFlexibleResult<
9101 'static,
9102 crate::wire::CapabilityStoreDictionaryCopyResponse,
9103 crate::wire::CapabilityStoreError,
9104 >;
9105 }
9106
9107 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
9108 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9109
9110 fn respond(response: ___R) -> Self::Output {
9111 ::fidl_next::FlexibleResult::Ok(response)
9112 }
9113 }
9114
9115 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
9116 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9117
9118 fn respond_err(response: ___R) -> Self::Output {
9119 ::fidl_next::FlexibleResult::Err(response)
9120 }
9121 }
9122
9123 pub struct DictionaryKeys;
9124
9125 impl ::fidl_next::Method for DictionaryKeys {
9126 const ORDINAL: u64 = 597577248872787102;
9127 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9128 ::fidl_next::protocol::Flexibility::Flexible;
9129
9130 type Protocol = crate::CapabilityStore;
9131
9132 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
9133 }
9134
9135 impl ::fidl_next::TwoWayMethod for DictionaryKeys {
9136 type Response = ::fidl_next::WireFlexibleResult<
9137 'static,
9138 crate::wire::CapabilityStoreDictionaryKeysResponse,
9139 crate::wire::CapabilityStoreError,
9140 >;
9141 }
9142
9143 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
9144 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9145
9146 fn respond(response: ___R) -> Self::Output {
9147 ::fidl_next::FlexibleResult::Ok(response)
9148 }
9149 }
9150
9151 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
9152 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9153
9154 fn respond_err(response: ___R) -> Self::Output {
9155 ::fidl_next::FlexibleResult::Err(response)
9156 }
9157 }
9158
9159 pub struct DictionaryEnumerate;
9160
9161 impl ::fidl_next::Method for DictionaryEnumerate {
9162 const ORDINAL: u64 = 964467096271472193;
9163 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9164 ::fidl_next::protocol::Flexibility::Flexible;
9165
9166 type Protocol = crate::CapabilityStore;
9167
9168 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
9169 }
9170
9171 impl ::fidl_next::TwoWayMethod for DictionaryEnumerate {
9172 type Response = ::fidl_next::WireFlexibleResult<
9173 'static,
9174 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
9175 crate::wire::CapabilityStoreError,
9176 >;
9177 }
9178
9179 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
9180 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9181
9182 fn respond(response: ___R) -> Self::Output {
9183 ::fidl_next::FlexibleResult::Ok(response)
9184 }
9185 }
9186
9187 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
9188 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9189
9190 fn respond_err(response: ___R) -> Self::Output {
9191 ::fidl_next::FlexibleResult::Err(response)
9192 }
9193 }
9194
9195 pub struct DictionaryDrain;
9196
9197 impl ::fidl_next::Method for DictionaryDrain {
9198 const ORDINAL: u64 = 2928364469569621208;
9199 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9200 ::fidl_next::protocol::Flexibility::Flexible;
9201
9202 type Protocol = crate::CapabilityStore;
9203
9204 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
9205 }
9206
9207 impl ::fidl_next::TwoWayMethod for DictionaryDrain {
9208 type Response = ::fidl_next::WireFlexibleResult<
9209 'static,
9210 crate::wire::CapabilityStoreDictionaryDrainResponse,
9211 crate::wire::CapabilityStoreError,
9212 >;
9213 }
9214
9215 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
9216 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9217
9218 fn respond(response: ___R) -> Self::Output {
9219 ::fidl_next::FlexibleResult::Ok(response)
9220 }
9221 }
9222
9223 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
9224 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9225
9226 fn respond_err(response: ___R) -> Self::Output {
9227 ::fidl_next::FlexibleResult::Err(response)
9228 }
9229 }
9230
9231 pub struct CreateServiceAggregate;
9232
9233 impl ::fidl_next::Method for CreateServiceAggregate {
9234 const ORDINAL: u64 = 5009147843253209178;
9235 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9236 ::fidl_next::protocol::Flexibility::Flexible;
9237
9238 type Protocol = crate::CapabilityStore;
9239
9240 type Request = crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>;
9241 }
9242
9243 impl ::fidl_next::TwoWayMethod for CreateServiceAggregate {
9244 type Response = ::fidl_next::WireFlexibleResult<
9245 'static,
9246 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
9247 crate::wire::CapabilityStoreError,
9248 >;
9249 }
9250
9251 impl<___R> ::fidl_next::Respond<___R> for CreateServiceAggregate {
9252 type Output = ::fidl_next::FlexibleResult<
9253 crate::generic::CapabilityStoreCreateServiceAggregateResponse<___R>,
9254 ::fidl_next::util::Never,
9255 >;
9256
9257 fn respond(response: ___R) -> Self::Output {
9258 ::fidl_next::FlexibleResult::Ok(
9259 crate::generic::CapabilityStoreCreateServiceAggregateResponse {
9260 aggregate_dir_connector: response,
9261 },
9262 )
9263 }
9264 }
9265
9266 impl<___R> ::fidl_next::RespondErr<___R> for CreateServiceAggregate {
9267 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9268
9269 fn respond_err(response: ___R) -> Self::Output {
9270 ::fidl_next::FlexibleResult::Err(response)
9271 }
9272 }
9273
9274 mod ___detail {
9275 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
9276 where
9277 ___T: ::fidl_next::Transport,
9278 {
9279 type Client = CapabilityStoreClient<___T>;
9280 type Server = CapabilityStoreServer<___T>;
9281 }
9282
9283 #[repr(transparent)]
9285 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
9286 #[allow(dead_code)]
9287 client: ::fidl_next::protocol::Client<___T>,
9288 }
9289
9290 impl<___T> CapabilityStoreClient<___T>
9291 where
9292 ___T: ::fidl_next::Transport,
9293 {
9294 #[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"]
9295 pub fn duplicate(
9296 &self,
9297
9298 id: impl ::fidl_next::Encode<
9299 ::fidl_next::WireU64,
9300 <___T as ::fidl_next::Transport>::SendBuffer,
9301 >,
9302
9303 dest_id: impl ::fidl_next::Encode<
9304 ::fidl_next::WireU64,
9305 <___T as ::fidl_next::Transport>::SendBuffer,
9306 >,
9307 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
9308 where
9309 <___T as ::fidl_next::Transport>::SendBuffer:
9310 ::fidl_next::encoder::InternalHandleEncoder,
9311 {
9312 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
9313 }
9314
9315 #[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"]
9316 pub fn duplicate_with<___R>(
9317 &self,
9318 request: ___R,
9319 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
9320 where
9321 ___R: ::fidl_next::Encode<
9322 crate::wire::CapabilityStoreDuplicateRequest,
9323 <___T as ::fidl_next::Transport>::SendBuffer,
9324 >,
9325 {
9326 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9327 6727592627741008260,
9328 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
9329 request,
9330 ))
9331 }
9332
9333 #[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"]
9334 pub fn drop(
9335 &self,
9336
9337 id: impl ::fidl_next::Encode<
9338 ::fidl_next::WireU64,
9339 <___T as ::fidl_next::Transport>::SendBuffer,
9340 >,
9341 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
9342 where
9343 <___T as ::fidl_next::Transport>::SendBuffer:
9344 ::fidl_next::encoder::InternalHandleEncoder,
9345 {
9346 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
9347 }
9348
9349 #[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"]
9350 pub fn drop_with<___R>(
9351 &self,
9352 request: ___R,
9353 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
9354 where
9355 ___R: ::fidl_next::Encode<
9356 crate::wire::CapabilityStoreDropRequest,
9357 <___T as ::fidl_next::Transport>::SendBuffer,
9358 >,
9359 {
9360 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9361 753328233834620249,
9362 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
9363 request,
9364 ))
9365 }
9366
9367 #[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"]
9368 pub fn export(
9369 &self,
9370
9371 id: impl ::fidl_next::Encode<
9372 ::fidl_next::WireU64,
9373 <___T as ::fidl_next::Transport>::SendBuffer,
9374 >,
9375 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
9376 where
9377 <___T as ::fidl_next::Transport>::SendBuffer:
9378 ::fidl_next::encoder::InternalHandleEncoder,
9379 {
9380 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
9381 }
9382
9383 #[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"]
9384 pub fn export_with<___R>(
9385 &self,
9386 request: ___R,
9387 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
9388 where
9389 ___R: ::fidl_next::Encode<
9390 crate::wire::CapabilityStoreExportRequest,
9391 <___T as ::fidl_next::Transport>::SendBuffer,
9392 >,
9393 {
9394 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9395 226159162093533951,
9396 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
9397 request,
9398 ))
9399 }
9400
9401 #[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"]
9402 pub fn import(
9403 &self,
9404
9405 id: impl ::fidl_next::Encode<
9406 ::fidl_next::WireU64,
9407 <___T as ::fidl_next::Transport>::SendBuffer,
9408 >,
9409
9410 capability: impl ::fidl_next::Encode<
9411 crate::wire::Capability<'static>,
9412 <___T as ::fidl_next::Transport>::SendBuffer,
9413 >,
9414 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
9415 where
9416 <___T as ::fidl_next::Transport>::SendBuffer:
9417 ::fidl_next::encoder::InternalHandleEncoder,
9418 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9419 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9420 {
9421 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
9422 }
9423
9424 #[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"]
9425 pub fn import_with<___R>(
9426 &self,
9427 request: ___R,
9428 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
9429 where
9430 ___R: ::fidl_next::Encode<
9431 crate::wire::CapabilityStoreImportRequest<'static>,
9432 <___T as ::fidl_next::Transport>::SendBuffer,
9433 >,
9434 {
9435 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9436 2276030276116435867,
9437 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
9438 request,
9439 ))
9440 }
9441
9442 #[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"]
9443 pub fn connector_create(
9444 &self,
9445
9446 id: impl ::fidl_next::Encode<
9447 ::fidl_next::WireU64,
9448 <___T as ::fidl_next::Transport>::SendBuffer,
9449 >,
9450
9451 receiver: impl ::fidl_next::Encode<
9452 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
9453 <___T as ::fidl_next::Transport>::SendBuffer,
9454 >,
9455 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
9456 where
9457 <___T as ::fidl_next::Transport>::SendBuffer:
9458 ::fidl_next::encoder::InternalHandleEncoder,
9459 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9460 {
9461 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
9462 id,
9463
9464 receiver,
9465 })
9466 }
9467
9468 #[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"]
9469 pub fn connector_create_with<___R>(
9470 &self,
9471 request: ___R,
9472 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
9473 where
9474 ___R: ::fidl_next::Encode<
9475 crate::wire::CapabilityStoreConnectorCreateRequest,
9476 <___T as ::fidl_next::Transport>::SendBuffer,
9477 >,
9478 {
9479 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9480 2979461408102095909,
9481 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
9482 request,
9483 ))
9484 }
9485
9486 #[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"]
9487 pub fn connector_open(
9488 &self,
9489
9490 id: impl ::fidl_next::Encode<
9491 ::fidl_next::WireU64,
9492 <___T as ::fidl_next::Transport>::SendBuffer,
9493 >,
9494
9495 server_end: impl ::fidl_next::Encode<
9496 ::fidl_next::fuchsia::WireChannel,
9497 <___T as ::fidl_next::Transport>::SendBuffer,
9498 >,
9499 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
9500 where
9501 <___T as ::fidl_next::Transport>::SendBuffer:
9502 ::fidl_next::encoder::InternalHandleEncoder,
9503 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9504 {
9505 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
9506 id,
9507
9508 server_end,
9509 })
9510 }
9511
9512 #[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"]
9513 pub fn connector_open_with<___R>(
9514 &self,
9515 request: ___R,
9516 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
9517 where
9518 ___R: ::fidl_next::Encode<
9519 crate::wire::CapabilityStoreConnectorOpenRequest,
9520 <___T as ::fidl_next::Transport>::SendBuffer,
9521 >,
9522 {
9523 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9524 6016362336453278623,
9525 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
9526 request,
9527 ))
9528 }
9529
9530 #[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"]
9531 pub fn dir_connector_create(
9532 &self,
9533
9534 id: impl ::fidl_next::Encode<
9535 ::fidl_next::WireU64,
9536 <___T as ::fidl_next::Transport>::SendBuffer,
9537 >,
9538
9539 receiver: impl ::fidl_next::Encode<
9540 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
9541 <___T as ::fidl_next::Transport>::SendBuffer,
9542 >,
9543 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
9544 where
9545 <___T as ::fidl_next::Transport>::SendBuffer:
9546 ::fidl_next::encoder::InternalHandleEncoder,
9547 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9548 {
9549 self.dir_connector_create_with(
9550 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
9551 )
9552 }
9553
9554 #[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"]
9555 pub fn dir_connector_create_with<___R>(
9556 &self,
9557 request: ___R,
9558 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
9559 where
9560 ___R: ::fidl_next::Encode<
9561 crate::wire::CapabilityStoreDirConnectorCreateRequest,
9562 <___T as ::fidl_next::Transport>::SendBuffer,
9563 >,
9564 {
9565 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9566 1756747594275428795,
9567 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
9568 request,
9569 ))
9570 }
9571
9572 #[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"]
9573 pub fn dir_connector_open_with<___R>(
9574 &self,
9575 request: ___R,
9576 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
9577 where
9578 ___R: ::fidl_next::Encode<
9579 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
9580 <___T as ::fidl_next::Transport>::SendBuffer,
9581 >,
9582 {
9583 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9584 6219704004220369153,
9585 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
9586 request,
9587 ))
9588 }
9589
9590 #[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"]
9591 pub fn dictionary_create(
9592 &self,
9593
9594 id: impl ::fidl_next::Encode<
9595 ::fidl_next::WireU64,
9596 <___T as ::fidl_next::Transport>::SendBuffer,
9597 >,
9598 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
9599 where
9600 <___T as ::fidl_next::Transport>::SendBuffer:
9601 ::fidl_next::encoder::InternalHandleEncoder,
9602 {
9603 self.dictionary_create_with(
9604 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
9605 )
9606 }
9607
9608 #[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"]
9609 pub fn dictionary_create_with<___R>(
9610 &self,
9611 request: ___R,
9612 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
9613 where
9614 ___R: ::fidl_next::Encode<
9615 crate::wire::CapabilityStoreDictionaryCreateRequest,
9616 <___T as ::fidl_next::Transport>::SendBuffer,
9617 >,
9618 {
9619 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9620 7608770958894948499,
9621 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
9622 request,
9623 ))
9624 }
9625
9626 #[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"]
9627 pub fn dictionary_legacy_import(
9628 &self,
9629
9630 id: impl ::fidl_next::Encode<
9631 ::fidl_next::WireU64,
9632 <___T as ::fidl_next::Transport>::SendBuffer,
9633 >,
9634
9635 client_end: impl ::fidl_next::Encode<
9636 ::fidl_next::fuchsia::WireChannel,
9637 <___T as ::fidl_next::Transport>::SendBuffer,
9638 >,
9639 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
9640 where
9641 <___T as ::fidl_next::Transport>::SendBuffer:
9642 ::fidl_next::encoder::InternalHandleEncoder,
9643 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9644 {
9645 self.dictionary_legacy_import_with(
9646 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
9647 )
9648 }
9649
9650 #[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"]
9651 pub fn dictionary_legacy_import_with<___R>(
9652 &self,
9653 request: ___R,
9654 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
9655 where
9656 ___R: ::fidl_next::Encode<
9657 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
9658 <___T as ::fidl_next::Transport>::SendBuffer,
9659 >,
9660 {
9661 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9662 8285893703432012383,
9663 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
9664 request,
9665 ))
9666 }
9667
9668 #[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"]
9669 pub fn dictionary_legacy_export(
9670 &self,
9671
9672 id: impl ::fidl_next::Encode<
9673 ::fidl_next::WireU64,
9674 <___T as ::fidl_next::Transport>::SendBuffer,
9675 >,
9676
9677 server_end: impl ::fidl_next::Encode<
9678 ::fidl_next::fuchsia::WireChannel,
9679 <___T as ::fidl_next::Transport>::SendBuffer,
9680 >,
9681 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
9682 where
9683 <___T as ::fidl_next::Transport>::SendBuffer:
9684 ::fidl_next::encoder::InternalHandleEncoder,
9685 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9686 {
9687 self.dictionary_legacy_export_with(
9688 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
9689 )
9690 }
9691
9692 #[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"]
9693 pub fn dictionary_legacy_export_with<___R>(
9694 &self,
9695 request: ___R,
9696 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
9697 where
9698 ___R: ::fidl_next::Encode<
9699 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
9700 <___T as ::fidl_next::Transport>::SendBuffer,
9701 >,
9702 {
9703 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9704 4647175832683306445,
9705 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
9706 request,
9707 ))
9708 }
9709
9710 #[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"]
9711 pub fn dictionary_insert(
9712 &self,
9713
9714 id: impl ::fidl_next::Encode<
9715 ::fidl_next::WireU64,
9716 <___T as ::fidl_next::Transport>::SendBuffer,
9717 >,
9718
9719 item: impl ::fidl_next::Encode<
9720 crate::wire::DictionaryItem<'static>,
9721 <___T as ::fidl_next::Transport>::SendBuffer,
9722 >,
9723 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
9724 where
9725 <___T as ::fidl_next::Transport>::SendBuffer:
9726 ::fidl_next::encoder::InternalHandleEncoder,
9727 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9728 {
9729 self.dictionary_insert_with(
9730 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
9731 )
9732 }
9733
9734 #[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"]
9735 pub fn dictionary_insert_with<___R>(
9736 &self,
9737 request: ___R,
9738 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
9739 where
9740 ___R: ::fidl_next::Encode<
9741 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
9742 <___T as ::fidl_next::Transport>::SendBuffer,
9743 >,
9744 {
9745 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9746 8575443262986538023,
9747 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
9748 request,
9749 ))
9750 }
9751
9752 #[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"]
9753 pub fn dictionary_get(
9754 &self,
9755
9756 id: impl ::fidl_next::Encode<
9757 ::fidl_next::WireU64,
9758 <___T as ::fidl_next::Transport>::SendBuffer,
9759 >,
9760
9761 key: impl ::fidl_next::Encode<
9762 ::fidl_next::WireString<'static>,
9763 <___T as ::fidl_next::Transport>::SendBuffer,
9764 >,
9765
9766 dest_id: impl ::fidl_next::Encode<
9767 ::fidl_next::WireU64,
9768 <___T as ::fidl_next::Transport>::SendBuffer,
9769 >,
9770 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
9771 where
9772 <___T as ::fidl_next::Transport>::SendBuffer:
9773 ::fidl_next::encoder::InternalHandleEncoder,
9774 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9775 {
9776 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
9777 id,
9778
9779 key,
9780
9781 dest_id,
9782 })
9783 }
9784
9785 #[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"]
9786 pub fn dictionary_get_with<___R>(
9787 &self,
9788 request: ___R,
9789 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
9790 where
9791 ___R: ::fidl_next::Encode<
9792 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
9793 <___T as ::fidl_next::Transport>::SendBuffer,
9794 >,
9795 {
9796 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9797 5592951026866236882,
9798 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
9799 request,
9800 ))
9801 }
9802
9803 #[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"]
9804 pub fn dictionary_remove(
9805 &self,
9806
9807 id: impl ::fidl_next::Encode<
9808 ::fidl_next::WireU64,
9809 <___T as ::fidl_next::Transport>::SendBuffer,
9810 >,
9811
9812 key: impl ::fidl_next::Encode<
9813 ::fidl_next::WireString<'static>,
9814 <___T as ::fidl_next::Transport>::SendBuffer,
9815 >,
9816
9817 dest_id: impl ::fidl_next::Encode<
9818 ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
9819 <___T as ::fidl_next::Transport>::SendBuffer,
9820 >,
9821 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
9822 where
9823 <___T as ::fidl_next::Transport>::SendBuffer:
9824 ::fidl_next::encoder::InternalHandleEncoder,
9825 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9826 {
9827 self.dictionary_remove_with(
9828 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
9829 )
9830 }
9831
9832 #[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"]
9833 pub fn dictionary_remove_with<___R>(
9834 &self,
9835 request: ___R,
9836 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
9837 where
9838 ___R: ::fidl_next::Encode<
9839 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
9840 <___T as ::fidl_next::Transport>::SendBuffer,
9841 >,
9842 {
9843 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9844 343892214579320051,
9845 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
9846 request,
9847 ))
9848 }
9849
9850 #[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"]
9851 pub fn dictionary_copy(
9852 &self,
9853
9854 id: impl ::fidl_next::Encode<
9855 ::fidl_next::WireU64,
9856 <___T as ::fidl_next::Transport>::SendBuffer,
9857 >,
9858
9859 dest_id: impl ::fidl_next::Encode<
9860 ::fidl_next::WireU64,
9861 <___T as ::fidl_next::Transport>::SendBuffer,
9862 >,
9863 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
9864 where
9865 <___T as ::fidl_next::Transport>::SendBuffer:
9866 ::fidl_next::encoder::InternalHandleEncoder,
9867 {
9868 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
9869 id,
9870
9871 dest_id,
9872 })
9873 }
9874
9875 #[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"]
9876 pub fn dictionary_copy_with<___R>(
9877 &self,
9878 request: ___R,
9879 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
9880 where
9881 ___R: ::fidl_next::Encode<
9882 crate::wire::CapabilityStoreDictionaryCopyRequest,
9883 <___T as ::fidl_next::Transport>::SendBuffer,
9884 >,
9885 {
9886 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9887 3977783339739362383,
9888 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
9889 request,
9890 ))
9891 }
9892
9893 #[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"]
9894 pub fn dictionary_keys(
9895 &self,
9896
9897 id: impl ::fidl_next::Encode<
9898 ::fidl_next::WireU64,
9899 <___T as ::fidl_next::Transport>::SendBuffer,
9900 >,
9901
9902 iterator: impl ::fidl_next::Encode<
9903 ::fidl_next::ServerEnd<
9904 crate::DictionaryKeysIterator,
9905 ::fidl_next::fuchsia::WireChannel,
9906 >,
9907 <___T as ::fidl_next::Transport>::SendBuffer,
9908 >,
9909 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9910 where
9911 <___T as ::fidl_next::Transport>::SendBuffer:
9912 ::fidl_next::encoder::InternalHandleEncoder,
9913 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9914 {
9915 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
9916 id,
9917
9918 iterator,
9919 })
9920 }
9921
9922 #[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"]
9923 pub fn dictionary_keys_with<___R>(
9924 &self,
9925 request: ___R,
9926 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
9927 where
9928 ___R: ::fidl_next::Encode<
9929 crate::wire::CapabilityStoreDictionaryKeysRequest,
9930 <___T as ::fidl_next::Transport>::SendBuffer,
9931 >,
9932 {
9933 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9934 597577248872787102,
9935 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
9936 request,
9937 ))
9938 }
9939
9940 #[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"]
9941 pub fn dictionary_enumerate(
9942 &self,
9943
9944 id: impl ::fidl_next::Encode<
9945 ::fidl_next::WireU64,
9946 <___T as ::fidl_next::Transport>::SendBuffer,
9947 >,
9948
9949 iterator: impl ::fidl_next::Encode<
9950 ::fidl_next::ServerEnd<
9951 crate::DictionaryEnumerateIterator,
9952 ::fidl_next::fuchsia::WireChannel,
9953 >,
9954 <___T as ::fidl_next::Transport>::SendBuffer,
9955 >,
9956 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9957 where
9958 <___T as ::fidl_next::Transport>::SendBuffer:
9959 ::fidl_next::encoder::InternalHandleEncoder,
9960 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9961 {
9962 self.dictionary_enumerate_with(
9963 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
9964 )
9965 }
9966
9967 #[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"]
9968 pub fn dictionary_enumerate_with<___R>(
9969 &self,
9970 request: ___R,
9971 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
9972 where
9973 ___R: ::fidl_next::Encode<
9974 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
9975 <___T as ::fidl_next::Transport>::SendBuffer,
9976 >,
9977 {
9978 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9979 964467096271472193,
9980 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
9981 request,
9982 ))
9983 }
9984
9985 #[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"]
9986 pub fn dictionary_drain(
9987 &self,
9988
9989 id: impl ::fidl_next::Encode<
9990 ::fidl_next::WireU64,
9991 <___T as ::fidl_next::Transport>::SendBuffer,
9992 >,
9993
9994 iterator: impl ::fidl_next::Encode<
9995 ::fidl_next::ServerEnd<
9996 crate::DictionaryDrainIterator,
9997 ::fidl_next::fuchsia::WireOptionalChannel,
9998 >,
9999 <___T as ::fidl_next::Transport>::SendBuffer,
10000 >,
10001 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
10002 where
10003 <___T as ::fidl_next::Transport>::SendBuffer:
10004 ::fidl_next::encoder::InternalHandleEncoder,
10005 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10006 {
10007 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
10008 id,
10009
10010 iterator,
10011 })
10012 }
10013
10014 #[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"]
10015 pub fn dictionary_drain_with<___R>(
10016 &self,
10017 request: ___R,
10018 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
10019 where
10020 ___R: ::fidl_next::Encode<
10021 crate::wire::CapabilityStoreDictionaryDrainRequest,
10022 <___T as ::fidl_next::Transport>::SendBuffer,
10023 >,
10024 {
10025 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10026 2928364469569621208,
10027 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
10028 request,
10029 ))
10030 }
10031
10032 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10033 pub fn create_service_aggregate(
10034 &self,
10035
10036 sources: impl ::fidl_next::Encode<
10037 ::fidl_next::WireVector<'static, crate::wire::AggregateSource<'static>>,
10038 <___T as ::fidl_next::Transport>::SendBuffer,
10039 >,
10040 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
10041 where
10042 <___T as ::fidl_next::Transport>::SendBuffer:
10043 ::fidl_next::encoder::InternalHandleEncoder,
10044 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10045 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10046 {
10047 self.create_service_aggregate_with(
10048 crate::generic::CapabilityStoreCreateServiceAggregateRequest { sources },
10049 )
10050 }
10051
10052 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10053 pub fn create_service_aggregate_with<___R>(
10054 &self,
10055 request: ___R,
10056 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
10057 where
10058 ___R: ::fidl_next::Encode<
10059 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
10060 <___T as ::fidl_next::Transport>::SendBuffer,
10061 >,
10062 {
10063 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10064 5009147843253209178,
10065 <super::CreateServiceAggregate as ::fidl_next::Method>::FLEXIBILITY,
10066 request,
10067 ))
10068 }
10069 }
10070
10071 #[repr(transparent)]
10073 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
10074 server: ::fidl_next::protocol::Server<___T>,
10075 }
10076
10077 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
10078 }
10079}
10080
10081pub trait CapabilityStoreClientHandler<
10085 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10086 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10087>
10088{
10089 fn on_unknown_interaction(
10090 &mut self,
10091 ordinal: u64,
10092 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10093 ::core::future::ready(())
10094 }
10095}
10096
10097impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
10098where
10099 ___T: ::fidl_next::Transport,
10100{
10101 async fn on_unknown_interaction(&mut self, _: u64) {}
10102}
10103
10104impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
10105where
10106 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
10107 ___T: ::fidl_next::Transport,
10108{
10109 async fn on_event(
10110 handler: &mut ___H,
10111 ordinal: u64,
10112 flexibility: ::fidl_next::protocol::Flexibility,
10113 buffer: ___T::RecvBuffer,
10114 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10115 match ordinal {
10116 ordinal => {
10117 handler.on_unknown_interaction(ordinal).await;
10118 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10119 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10120 } else {
10121 Ok(())
10122 }
10123 }
10124 }
10125 }
10126}
10127
10128pub trait CapabilityStoreServerHandler<
10132 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10133 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10134>
10135{
10136 #[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"]
10137 fn duplicate(
10138 &mut self,
10139
10140 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
10141
10142 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
10143 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10144
10145 #[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"]
10146 fn drop(
10147 &mut self,
10148
10149 request: ::fidl_next::Request<capability_store::Drop, ___T>,
10150
10151 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
10152 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10153
10154 #[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"]
10155 fn export(
10156 &mut self,
10157
10158 request: ::fidl_next::Request<capability_store::Export, ___T>,
10159
10160 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
10161 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10162
10163 #[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"]
10164 fn import(
10165 &mut self,
10166
10167 request: ::fidl_next::Request<capability_store::Import, ___T>,
10168
10169 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
10170 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10171
10172 #[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"]
10173 fn connector_create(
10174 &mut self,
10175
10176 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
10177
10178 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
10179 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10180
10181 #[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"]
10182 fn connector_open(
10183 &mut self,
10184
10185 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
10186
10187 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
10188 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10189
10190 #[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"]
10191 fn dir_connector_create(
10192 &mut self,
10193
10194 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
10195
10196 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
10197 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10198
10199 #[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"]
10200 fn dir_connector_open(
10201 &mut self,
10202
10203 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
10204
10205 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
10206 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10207
10208 #[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"]
10209 fn dictionary_create(
10210 &mut self,
10211
10212 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
10213
10214 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
10215 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10216
10217 #[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"]
10218 fn dictionary_legacy_import(
10219 &mut self,
10220
10221 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
10222
10223 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
10224 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10225
10226 #[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"]
10227 fn dictionary_legacy_export(
10228 &mut self,
10229
10230 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
10231
10232 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
10233 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10234
10235 #[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"]
10236 fn dictionary_insert(
10237 &mut self,
10238
10239 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
10240
10241 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
10242 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10243
10244 #[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"]
10245 fn dictionary_get(
10246 &mut self,
10247
10248 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
10249
10250 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
10251 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10252
10253 #[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"]
10254 fn dictionary_remove(
10255 &mut self,
10256
10257 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
10258
10259 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
10260 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10261
10262 #[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"]
10263 fn dictionary_copy(
10264 &mut self,
10265
10266 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
10267
10268 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
10269 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10270
10271 #[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"]
10272 fn dictionary_keys(
10273 &mut self,
10274
10275 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
10276
10277 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
10278 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10279
10280 #[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"]
10281 fn dictionary_enumerate(
10282 &mut self,
10283
10284 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
10285
10286 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
10287 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10288
10289 #[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"]
10290 fn dictionary_drain(
10291 &mut self,
10292
10293 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
10294
10295 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
10296 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10297
10298 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10299 fn create_service_aggregate(
10300 &mut self,
10301
10302 request: ::fidl_next::Request<capability_store::CreateServiceAggregate, ___T>,
10303
10304 responder: ::fidl_next::Responder<capability_store::CreateServiceAggregate, ___T>,
10305 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10306
10307 fn on_unknown_interaction(
10308 &mut self,
10309 ordinal: u64,
10310 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10311 ::core::future::ready(())
10312 }
10313}
10314
10315impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
10316where
10317 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
10318 ___T: ::fidl_next::Transport,
10319 <capability_store::Duplicate as ::fidl_next::Method>::Request:
10320 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10321 <capability_store::Drop as ::fidl_next::Method>::Request:
10322 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10323 <capability_store::Export as ::fidl_next::Method>::Request:
10324 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10325 <capability_store::Import as ::fidl_next::Method>::Request:
10326 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10327 <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
10328 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10329 <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
10330 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10331 <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
10332 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10333 <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
10334 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10335 <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
10336 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10337 <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
10338 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10339 <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
10340 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10341 <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
10342 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10343 <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
10344 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10345 <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
10346 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10347 <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
10348 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10349 <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
10350 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10351 <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
10352 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10353 <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
10354 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10355 <capability_store::CreateServiceAggregate as ::fidl_next::Method>::Request:
10356 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10357{
10358 async fn on_one_way(
10359 handler: &mut ___H,
10360 ordinal: u64,
10361 flexibility: ::fidl_next::protocol::Flexibility,
10362 buffer: ___T::RecvBuffer,
10363 ) -> ::core::result::Result<
10364 (),
10365 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10366 > {
10367 match ordinal {
10368 ordinal => {
10369 handler.on_unknown_interaction(ordinal).await;
10370 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10371 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10372 } else {
10373 Ok(())
10374 }
10375 }
10376 }
10377 }
10378
10379 async fn on_two_way(
10380 handler: &mut ___H,
10381 ordinal: u64,
10382 flexibility: ::fidl_next::protocol::Flexibility,
10383 buffer: ___T::RecvBuffer,
10384 responder: ::fidl_next::protocol::Responder<___T>,
10385 ) -> ::core::result::Result<
10386 (),
10387 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10388 > {
10389 match ordinal {
10390 6727592627741008260 => {
10391 let responder = ::fidl_next::Responder::from_untyped(responder);
10392
10393 match ::fidl_next::DecoderExt::decode(buffer) {
10394 Ok(decoded) => {
10395 handler
10396 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
10397 .await;
10398 Ok(())
10399 }
10400 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10401 ordinal: 6727592627741008260,
10402 error,
10403 }),
10404 }
10405 }
10406
10407 753328233834620249 => {
10408 let responder = ::fidl_next::Responder::from_untyped(responder);
10409
10410 match ::fidl_next::DecoderExt::decode(buffer) {
10411 Ok(decoded) => {
10412 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
10413 Ok(())
10414 }
10415 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10416 ordinal: 753328233834620249,
10417 error,
10418 }),
10419 }
10420 }
10421
10422 226159162093533951 => {
10423 let responder = ::fidl_next::Responder::from_untyped(responder);
10424
10425 match ::fidl_next::DecoderExt::decode(buffer) {
10426 Ok(decoded) => {
10427 handler
10428 .export(::fidl_next::Request::from_decoded(decoded), responder)
10429 .await;
10430 Ok(())
10431 }
10432 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10433 ordinal: 226159162093533951,
10434 error,
10435 }),
10436 }
10437 }
10438
10439 2276030276116435867 => {
10440 let responder = ::fidl_next::Responder::from_untyped(responder);
10441
10442 match ::fidl_next::DecoderExt::decode(buffer) {
10443 Ok(decoded) => {
10444 handler
10445 .import(::fidl_next::Request::from_decoded(decoded), responder)
10446 .await;
10447 Ok(())
10448 }
10449 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10450 ordinal: 2276030276116435867,
10451 error,
10452 }),
10453 }
10454 }
10455
10456 2979461408102095909 => {
10457 let responder = ::fidl_next::Responder::from_untyped(responder);
10458
10459 match ::fidl_next::DecoderExt::decode(buffer) {
10460 Ok(decoded) => {
10461 handler
10462 .connector_create(
10463 ::fidl_next::Request::from_decoded(decoded),
10464 responder,
10465 )
10466 .await;
10467 Ok(())
10468 }
10469 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10470 ordinal: 2979461408102095909,
10471 error,
10472 }),
10473 }
10474 }
10475
10476 6016362336453278623 => {
10477 let responder = ::fidl_next::Responder::from_untyped(responder);
10478
10479 match ::fidl_next::DecoderExt::decode(buffer) {
10480 Ok(decoded) => {
10481 handler
10482 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
10483 .await;
10484 Ok(())
10485 }
10486 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10487 ordinal: 6016362336453278623,
10488 error,
10489 }),
10490 }
10491 }
10492
10493 1756747594275428795 => {
10494 let responder = ::fidl_next::Responder::from_untyped(responder);
10495
10496 match ::fidl_next::DecoderExt::decode(buffer) {
10497 Ok(decoded) => {
10498 handler
10499 .dir_connector_create(
10500 ::fidl_next::Request::from_decoded(decoded),
10501 responder,
10502 )
10503 .await;
10504 Ok(())
10505 }
10506 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10507 ordinal: 1756747594275428795,
10508 error,
10509 }),
10510 }
10511 }
10512
10513 6219704004220369153 => {
10514 let responder = ::fidl_next::Responder::from_untyped(responder);
10515
10516 match ::fidl_next::DecoderExt::decode(buffer) {
10517 Ok(decoded) => {
10518 handler
10519 .dir_connector_open(
10520 ::fidl_next::Request::from_decoded(decoded),
10521 responder,
10522 )
10523 .await;
10524 Ok(())
10525 }
10526 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10527 ordinal: 6219704004220369153,
10528 error,
10529 }),
10530 }
10531 }
10532
10533 7608770958894948499 => {
10534 let responder = ::fidl_next::Responder::from_untyped(responder);
10535
10536 match ::fidl_next::DecoderExt::decode(buffer) {
10537 Ok(decoded) => {
10538 handler
10539 .dictionary_create(
10540 ::fidl_next::Request::from_decoded(decoded),
10541 responder,
10542 )
10543 .await;
10544 Ok(())
10545 }
10546 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10547 ordinal: 7608770958894948499,
10548 error,
10549 }),
10550 }
10551 }
10552
10553 8285893703432012383 => {
10554 let responder = ::fidl_next::Responder::from_untyped(responder);
10555
10556 match ::fidl_next::DecoderExt::decode(buffer) {
10557 Ok(decoded) => {
10558 handler
10559 .dictionary_legacy_import(
10560 ::fidl_next::Request::from_decoded(decoded),
10561 responder,
10562 )
10563 .await;
10564 Ok(())
10565 }
10566 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10567 ordinal: 8285893703432012383,
10568 error,
10569 }),
10570 }
10571 }
10572
10573 4647175832683306445 => {
10574 let responder = ::fidl_next::Responder::from_untyped(responder);
10575
10576 match ::fidl_next::DecoderExt::decode(buffer) {
10577 Ok(decoded) => {
10578 handler
10579 .dictionary_legacy_export(
10580 ::fidl_next::Request::from_decoded(decoded),
10581 responder,
10582 )
10583 .await;
10584 Ok(())
10585 }
10586 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10587 ordinal: 4647175832683306445,
10588 error,
10589 }),
10590 }
10591 }
10592
10593 8575443262986538023 => {
10594 let responder = ::fidl_next::Responder::from_untyped(responder);
10595
10596 match ::fidl_next::DecoderExt::decode(buffer) {
10597 Ok(decoded) => {
10598 handler
10599 .dictionary_insert(
10600 ::fidl_next::Request::from_decoded(decoded),
10601 responder,
10602 )
10603 .await;
10604 Ok(())
10605 }
10606 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10607 ordinal: 8575443262986538023,
10608 error,
10609 }),
10610 }
10611 }
10612
10613 5592951026866236882 => {
10614 let responder = ::fidl_next::Responder::from_untyped(responder);
10615
10616 match ::fidl_next::DecoderExt::decode(buffer) {
10617 Ok(decoded) => {
10618 handler
10619 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
10620 .await;
10621 Ok(())
10622 }
10623 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10624 ordinal: 5592951026866236882,
10625 error,
10626 }),
10627 }
10628 }
10629
10630 343892214579320051 => {
10631 let responder = ::fidl_next::Responder::from_untyped(responder);
10632
10633 match ::fidl_next::DecoderExt::decode(buffer) {
10634 Ok(decoded) => {
10635 handler
10636 .dictionary_remove(
10637 ::fidl_next::Request::from_decoded(decoded),
10638 responder,
10639 )
10640 .await;
10641 Ok(())
10642 }
10643 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10644 ordinal: 343892214579320051,
10645 error,
10646 }),
10647 }
10648 }
10649
10650 3977783339739362383 => {
10651 let responder = ::fidl_next::Responder::from_untyped(responder);
10652
10653 match ::fidl_next::DecoderExt::decode(buffer) {
10654 Ok(decoded) => {
10655 handler
10656 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
10657 .await;
10658 Ok(())
10659 }
10660 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10661 ordinal: 3977783339739362383,
10662 error,
10663 }),
10664 }
10665 }
10666
10667 597577248872787102 => {
10668 let responder = ::fidl_next::Responder::from_untyped(responder);
10669
10670 match ::fidl_next::DecoderExt::decode(buffer) {
10671 Ok(decoded) => {
10672 handler
10673 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
10674 .await;
10675 Ok(())
10676 }
10677 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10678 ordinal: 597577248872787102,
10679 error,
10680 }),
10681 }
10682 }
10683
10684 964467096271472193 => {
10685 let responder = ::fidl_next::Responder::from_untyped(responder);
10686
10687 match ::fidl_next::DecoderExt::decode(buffer) {
10688 Ok(decoded) => {
10689 handler
10690 .dictionary_enumerate(
10691 ::fidl_next::Request::from_decoded(decoded),
10692 responder,
10693 )
10694 .await;
10695 Ok(())
10696 }
10697 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10698 ordinal: 964467096271472193,
10699 error,
10700 }),
10701 }
10702 }
10703
10704 2928364469569621208 => {
10705 let responder = ::fidl_next::Responder::from_untyped(responder);
10706
10707 match ::fidl_next::DecoderExt::decode(buffer) {
10708 Ok(decoded) => {
10709 handler
10710 .dictionary_drain(
10711 ::fidl_next::Request::from_decoded(decoded),
10712 responder,
10713 )
10714 .await;
10715 Ok(())
10716 }
10717 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10718 ordinal: 2928364469569621208,
10719 error,
10720 }),
10721 }
10722 }
10723
10724 5009147843253209178 => {
10725 let responder = ::fidl_next::Responder::from_untyped(responder);
10726
10727 match ::fidl_next::DecoderExt::decode(buffer) {
10728 Ok(decoded) => {
10729 handler
10730 .create_service_aggregate(
10731 ::fidl_next::Request::from_decoded(decoded),
10732 responder,
10733 )
10734 .await;
10735 Ok(())
10736 }
10737 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10738 ordinal: 5009147843253209178,
10739 error,
10740 }),
10741 }
10742 }
10743
10744 ordinal => {
10745 handler.on_unknown_interaction(ordinal).await;
10746 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10747 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10748 } else {
10749 responder
10750 .respond(
10751 ordinal,
10752 flexibility,
10753 ::fidl_next::Flexible::<()>::FrameworkErr(
10754 ::fidl_next::FrameworkError::UnknownMethod,
10755 ),
10756 )
10757 .expect("encoding a framework error should never fail")
10758 .await?;
10759 Ok(())
10760 }
10761 }
10762 }
10763 }
10764}
10765
10766#[derive(PartialEq, Debug)]
10768pub struct ConnectorRouter;
10769
10770impl ::fidl_next::Discoverable for ConnectorRouter {
10771 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
10772}
10773
10774#[cfg(target_os = "fuchsia")]
10775impl ::fidl_next::HasTransport for ConnectorRouter {
10776 type Transport = ::fidl_next::fuchsia::zx::Channel;
10777}
10778
10779pub mod connector_router {
10780 pub mod prelude {
10781 pub use crate::{
10782 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
10783 connector_router,
10784 };
10785
10786 pub use crate::natural::ConnectorRouterRouteResponse;
10787
10788 pub use crate::natural::RouteRequest;
10789
10790 pub use crate::natural::RouterError;
10791 }
10792
10793 pub struct Route;
10794
10795 impl ::fidl_next::Method for Route {
10796 const ORDINAL: u64 = 8420527046218942310;
10797 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10798 ::fidl_next::protocol::Flexibility::Flexible;
10799
10800 type Protocol = crate::ConnectorRouter;
10801
10802 type Request = crate::wire::RouteRequest<'static>;
10803 }
10804
10805 impl ::fidl_next::TwoWayMethod for Route {
10806 type Response = ::fidl_next::WireFlexibleResult<
10807 'static,
10808 crate::wire::ConnectorRouterRouteResponse,
10809 crate::wire::RouterError,
10810 >;
10811 }
10812
10813 impl<___R> ::fidl_next::Respond<___R> for Route {
10814 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
10815
10816 fn respond(response: ___R) -> Self::Output {
10817 ::fidl_next::FlexibleResult::Ok(response)
10818 }
10819 }
10820
10821 impl<___R> ::fidl_next::RespondErr<___R> for Route {
10822 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
10823
10824 fn respond_err(response: ___R) -> Self::Output {
10825 ::fidl_next::FlexibleResult::Err(response)
10826 }
10827 }
10828
10829 mod ___detail {
10830 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
10831 where
10832 ___T: ::fidl_next::Transport,
10833 {
10834 type Client = ConnectorRouterClient<___T>;
10835 type Server = ConnectorRouterServer<___T>;
10836 }
10837
10838 #[repr(transparent)]
10840 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
10841 #[allow(dead_code)]
10842 client: ::fidl_next::protocol::Client<___T>,
10843 }
10844
10845 impl<___T> ConnectorRouterClient<___T>
10846 where
10847 ___T: ::fidl_next::Transport,
10848 {
10849 pub fn route_with<___R>(
10850 &self,
10851 request: ___R,
10852 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10853 where
10854 ___R: ::fidl_next::Encode<
10855 crate::wire::RouteRequest<'static>,
10856 <___T as ::fidl_next::Transport>::SendBuffer,
10857 >,
10858 {
10859 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10860 8420527046218942310,
10861 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
10862 request,
10863 ))
10864 }
10865 }
10866
10867 #[repr(transparent)]
10869 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
10870 server: ::fidl_next::protocol::Server<___T>,
10871 }
10872
10873 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
10874 }
10875}
10876
10877pub trait ConnectorRouterClientHandler<
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> ConnectorRouterClientHandler<___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 ConnectorRouter
10901where
10902 ___H: ConnectorRouterClientHandler<___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 ConnectorRouterServerHandler<
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 fn route(
10933 &mut self,
10934
10935 request: ::fidl_next::Request<connector_router::Route, ___T>,
10936
10937 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
10938 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10939
10940 fn on_unknown_interaction(
10941 &mut self,
10942 ordinal: u64,
10943 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10944 ::core::future::ready(())
10945 }
10946}
10947
10948impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
10949where
10950 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
10951 ___T: ::fidl_next::Transport,
10952 <connector_router::Route as ::fidl_next::Method>::Request:
10953 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10954{
10955 async fn on_one_way(
10956 handler: &mut ___H,
10957 ordinal: u64,
10958 flexibility: ::fidl_next::protocol::Flexibility,
10959 buffer: ___T::RecvBuffer,
10960 ) -> ::core::result::Result<
10961 (),
10962 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10963 > {
10964 match ordinal {
10965 ordinal => {
10966 handler.on_unknown_interaction(ordinal).await;
10967 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10968 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10969 } else {
10970 Ok(())
10971 }
10972 }
10973 }
10974 }
10975
10976 async fn on_two_way(
10977 handler: &mut ___H,
10978 ordinal: u64,
10979 flexibility: ::fidl_next::protocol::Flexibility,
10980 buffer: ___T::RecvBuffer,
10981 responder: ::fidl_next::protocol::Responder<___T>,
10982 ) -> ::core::result::Result<
10983 (),
10984 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10985 > {
10986 match ordinal {
10987 8420527046218942310 => {
10988 let responder = ::fidl_next::Responder::from_untyped(responder);
10989
10990 match ::fidl_next::DecoderExt::decode(buffer) {
10991 Ok(decoded) => {
10992 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
10993 Ok(())
10994 }
10995 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10996 ordinal: 8420527046218942310,
10997 error,
10998 }),
10999 }
11000 }
11001
11002 ordinal => {
11003 handler.on_unknown_interaction(ordinal).await;
11004 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11005 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11006 } else {
11007 responder
11008 .respond(
11009 ordinal,
11010 flexibility,
11011 ::fidl_next::Flexible::<()>::FrameworkErr(
11012 ::fidl_next::FrameworkError::UnknownMethod,
11013 ),
11014 )
11015 .expect("encoding a framework error should never fail")
11016 .await?;
11017 Ok(())
11018 }
11019 }
11020 }
11021 }
11022}
11023
11024#[derive(PartialEq, Debug)]
11026pub struct DataRouter;
11027
11028impl ::fidl_next::Discoverable for DataRouter {
11029 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
11030}
11031
11032#[cfg(target_os = "fuchsia")]
11033impl ::fidl_next::HasTransport for DataRouter {
11034 type Transport = ::fidl_next::fuchsia::zx::Channel;
11035}
11036
11037pub mod data_router {
11038 pub mod prelude {
11039 pub use crate::{
11040 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
11041 };
11042
11043 pub use crate::natural::DataRouterRouteResponse;
11044
11045 pub use crate::natural::RouteRequest;
11046
11047 pub use crate::natural::RouterError;
11048 }
11049
11050 pub struct Route;
11051
11052 impl ::fidl_next::Method for Route {
11053 const ORDINAL: u64 = 3352890635970754564;
11054 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11055 ::fidl_next::protocol::Flexibility::Flexible;
11056
11057 type Protocol = crate::DataRouter;
11058
11059 type Request = crate::wire::RouteRequest<'static>;
11060 }
11061
11062 impl ::fidl_next::TwoWayMethod for Route {
11063 type Response = ::fidl_next::WireFlexibleResult<
11064 'static,
11065 crate::wire::DataRouterRouteResponse<'static>,
11066 crate::wire::RouterError,
11067 >;
11068 }
11069
11070 impl<___R> ::fidl_next::Respond<___R> for Route {
11071 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11072
11073 fn respond(response: ___R) -> Self::Output {
11074 ::fidl_next::FlexibleResult::Ok(response)
11075 }
11076 }
11077
11078 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11079 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11080
11081 fn respond_err(response: ___R) -> Self::Output {
11082 ::fidl_next::FlexibleResult::Err(response)
11083 }
11084 }
11085
11086 mod ___detail {
11087 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
11088 where
11089 ___T: ::fidl_next::Transport,
11090 {
11091 type Client = DataRouterClient<___T>;
11092 type Server = DataRouterServer<___T>;
11093 }
11094
11095 #[repr(transparent)]
11097 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
11098 #[allow(dead_code)]
11099 client: ::fidl_next::protocol::Client<___T>,
11100 }
11101
11102 impl<___T> DataRouterClient<___T>
11103 where
11104 ___T: ::fidl_next::Transport,
11105 {
11106 pub fn route_with<___R>(
11107 &self,
11108 request: ___R,
11109 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11110 where
11111 ___R: ::fidl_next::Encode<
11112 crate::wire::RouteRequest<'static>,
11113 <___T as ::fidl_next::Transport>::SendBuffer,
11114 >,
11115 {
11116 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11117 3352890635970754564,
11118 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11119 request,
11120 ))
11121 }
11122 }
11123
11124 #[repr(transparent)]
11126 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
11127 server: ::fidl_next::protocol::Server<___T>,
11128 }
11129
11130 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
11131 }
11132}
11133
11134pub trait DataRouterClientHandler<
11138 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11139 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11140>
11141{
11142 fn on_unknown_interaction(
11143 &mut self,
11144 ordinal: u64,
11145 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11146 ::core::future::ready(())
11147 }
11148}
11149
11150impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11151where
11152 ___T: ::fidl_next::Transport,
11153{
11154 async fn on_unknown_interaction(&mut self, _: u64) {}
11155}
11156
11157impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
11158where
11159 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
11160 ___T: ::fidl_next::Transport,
11161{
11162 async fn on_event(
11163 handler: &mut ___H,
11164 ordinal: u64,
11165 flexibility: ::fidl_next::protocol::Flexibility,
11166 buffer: ___T::RecvBuffer,
11167 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11168 match ordinal {
11169 ordinal => {
11170 handler.on_unknown_interaction(ordinal).await;
11171 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11172 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11173 } else {
11174 Ok(())
11175 }
11176 }
11177 }
11178 }
11179}
11180
11181pub trait DataRouterServerHandler<
11185 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11186 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11187>
11188{
11189 fn route(
11190 &mut self,
11191
11192 request: ::fidl_next::Request<data_router::Route, ___T>,
11193
11194 responder: ::fidl_next::Responder<data_router::Route, ___T>,
11195 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11196
11197 fn on_unknown_interaction(
11198 &mut self,
11199 ordinal: u64,
11200 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11201 ::core::future::ready(())
11202 }
11203}
11204
11205impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
11206where
11207 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
11208 ___T: ::fidl_next::Transport,
11209 <data_router::Route as ::fidl_next::Method>::Request:
11210 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11211{
11212 async fn on_one_way(
11213 handler: &mut ___H,
11214 ordinal: u64,
11215 flexibility: ::fidl_next::protocol::Flexibility,
11216 buffer: ___T::RecvBuffer,
11217 ) -> ::core::result::Result<
11218 (),
11219 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11220 > {
11221 match ordinal {
11222 ordinal => {
11223 handler.on_unknown_interaction(ordinal).await;
11224 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11225 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11226 } else {
11227 Ok(())
11228 }
11229 }
11230 }
11231 }
11232
11233 async fn on_two_way(
11234 handler: &mut ___H,
11235 ordinal: u64,
11236 flexibility: ::fidl_next::protocol::Flexibility,
11237 buffer: ___T::RecvBuffer,
11238 responder: ::fidl_next::protocol::Responder<___T>,
11239 ) -> ::core::result::Result<
11240 (),
11241 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11242 > {
11243 match ordinal {
11244 3352890635970754564 => {
11245 let responder = ::fidl_next::Responder::from_untyped(responder);
11246
11247 match ::fidl_next::DecoderExt::decode(buffer) {
11248 Ok(decoded) => {
11249 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11250 Ok(())
11251 }
11252 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11253 ordinal: 3352890635970754564,
11254 error,
11255 }),
11256 }
11257 }
11258
11259 ordinal => {
11260 handler.on_unknown_interaction(ordinal).await;
11261 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11262 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11263 } else {
11264 responder
11265 .respond(
11266 ordinal,
11267 flexibility,
11268 ::fidl_next::Flexible::<()>::FrameworkErr(
11269 ::fidl_next::FrameworkError::UnknownMethod,
11270 ),
11271 )
11272 .expect("encoding a framework error should never fail")
11273 .await?;
11274 Ok(())
11275 }
11276 }
11277 }
11278 }
11279}
11280
11281#[derive(PartialEq, Debug)]
11283pub struct DictionaryDrainIterator;
11284
11285#[cfg(target_os = "fuchsia")]
11286impl ::fidl_next::HasTransport for DictionaryDrainIterator {
11287 type Transport = ::fidl_next::fuchsia::zx::Channel;
11288}
11289
11290pub mod dictionary_drain_iterator {
11291 pub mod prelude {
11292 pub use crate::{
11293 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
11294 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
11295 };
11296
11297 pub use crate::natural::CapabilityStoreError;
11298
11299 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
11300
11301 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
11302 }
11303
11304 pub struct GetNext;
11305
11306 impl ::fidl_next::Method for GetNext {
11307 const ORDINAL: u64 = 5728722530628427873;
11308 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11309 ::fidl_next::protocol::Flexibility::Flexible;
11310
11311 type Protocol = crate::DictionaryDrainIterator;
11312
11313 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
11314 }
11315
11316 impl ::fidl_next::TwoWayMethod for GetNext {
11317 type Response = ::fidl_next::WireFlexibleResult<
11318 'static,
11319 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
11320 crate::wire::CapabilityStoreError,
11321 >;
11322 }
11323
11324 impl<___R> ::fidl_next::Respond<___R> for GetNext {
11325 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11326
11327 fn respond(response: ___R) -> Self::Output {
11328 ::fidl_next::FlexibleResult::Ok(response)
11329 }
11330 }
11331
11332 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
11333 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11334
11335 fn respond_err(response: ___R) -> Self::Output {
11336 ::fidl_next::FlexibleResult::Err(response)
11337 }
11338 }
11339
11340 mod ___detail {
11341 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
11342 where
11343 ___T: ::fidl_next::Transport,
11344 {
11345 type Client = DictionaryDrainIteratorClient<___T>;
11346 type Server = DictionaryDrainIteratorServer<___T>;
11347 }
11348
11349 #[repr(transparent)]
11351 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
11352 #[allow(dead_code)]
11353 client: ::fidl_next::protocol::Client<___T>,
11354 }
11355
11356 impl<___T> DictionaryDrainIteratorClient<___T>
11357 where
11358 ___T: ::fidl_next::Transport,
11359 {
11360 #[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"]
11361 pub fn get_next(
11362 &self,
11363
11364 start_id: impl ::fidl_next::Encode<
11365 ::fidl_next::WireU64,
11366 <___T as ::fidl_next::Transport>::SendBuffer,
11367 >,
11368
11369 limit: impl ::fidl_next::Encode<
11370 ::fidl_next::WireU32,
11371 <___T as ::fidl_next::Transport>::SendBuffer,
11372 >,
11373 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11374 where
11375 <___T as ::fidl_next::Transport>::SendBuffer:
11376 ::fidl_next::encoder::InternalHandleEncoder,
11377 {
11378 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
11379 start_id,
11380
11381 limit,
11382 })
11383 }
11384
11385 #[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"]
11386 pub fn get_next_with<___R>(
11387 &self,
11388 request: ___R,
11389 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11390 where
11391 ___R: ::fidl_next::Encode<
11392 crate::wire::DictionaryDrainIteratorGetNextRequest,
11393 <___T as ::fidl_next::Transport>::SendBuffer,
11394 >,
11395 {
11396 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11397 5728722530628427873,
11398 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
11399 request,
11400 ))
11401 }
11402 }
11403
11404 #[repr(transparent)]
11406 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
11407 server: ::fidl_next::protocol::Server<___T>,
11408 }
11409
11410 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11411 }
11412}
11413
11414pub trait DictionaryDrainIteratorClientHandler<
11418 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11419 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11420>
11421{
11422 fn on_unknown_interaction(
11423 &mut self,
11424 ordinal: u64,
11425 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11426 ::core::future::ready(())
11427 }
11428}
11429
11430impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11431where
11432 ___T: ::fidl_next::Transport,
11433{
11434 async fn on_unknown_interaction(&mut self, _: u64) {}
11435}
11436
11437impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
11438where
11439 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
11440 ___T: ::fidl_next::Transport,
11441{
11442 async fn on_event(
11443 handler: &mut ___H,
11444 ordinal: u64,
11445 flexibility: ::fidl_next::protocol::Flexibility,
11446 buffer: ___T::RecvBuffer,
11447 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
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
11461pub trait DictionaryDrainIteratorServerHandler<
11465 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11466 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11467>
11468{
11469 #[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"]
11470 fn get_next(
11471 &mut self,
11472
11473 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
11474
11475 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
11476 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11477
11478 fn on_unknown_interaction(
11479 &mut self,
11480 ordinal: u64,
11481 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11482 ::core::future::ready(())
11483 }
11484}
11485
11486impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
11487where
11488 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
11489 ___T: ::fidl_next::Transport,
11490 <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
11491 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11492{
11493 async fn on_one_way(
11494 handler: &mut ___H,
11495 ordinal: u64,
11496 flexibility: ::fidl_next::protocol::Flexibility,
11497 buffer: ___T::RecvBuffer,
11498 ) -> ::core::result::Result<
11499 (),
11500 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11501 > {
11502 match ordinal {
11503 ordinal => {
11504 handler.on_unknown_interaction(ordinal).await;
11505 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11506 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11507 } else {
11508 Ok(())
11509 }
11510 }
11511 }
11512 }
11513
11514 async fn on_two_way(
11515 handler: &mut ___H,
11516 ordinal: u64,
11517 flexibility: ::fidl_next::protocol::Flexibility,
11518 buffer: ___T::RecvBuffer,
11519 responder: ::fidl_next::protocol::Responder<___T>,
11520 ) -> ::core::result::Result<
11521 (),
11522 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11523 > {
11524 match ordinal {
11525 5728722530628427873 => {
11526 let responder = ::fidl_next::Responder::from_untyped(responder);
11527
11528 match ::fidl_next::DecoderExt::decode(buffer) {
11529 Ok(decoded) => {
11530 handler
11531 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
11532 .await;
11533 Ok(())
11534 }
11535 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11536 ordinal: 5728722530628427873,
11537 error,
11538 }),
11539 }
11540 }
11541
11542 ordinal => {
11543 handler.on_unknown_interaction(ordinal).await;
11544 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11545 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11546 } else {
11547 responder
11548 .respond(
11549 ordinal,
11550 flexibility,
11551 ::fidl_next::Flexible::<()>::FrameworkErr(
11552 ::fidl_next::FrameworkError::UnknownMethod,
11553 ),
11554 )
11555 .expect("encoding a framework error should never fail")
11556 .await?;
11557 Ok(())
11558 }
11559 }
11560 }
11561 }
11562}
11563
11564#[derive(PartialEq, Debug)]
11566pub struct DictionaryEnumerateIterator;
11567
11568#[cfg(target_os = "fuchsia")]
11569impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
11570 type Transport = ::fidl_next::fuchsia::zx::Channel;
11571}
11572
11573pub mod dictionary_enumerate_iterator {
11574 pub mod prelude {
11575 pub use crate::{
11576 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
11577 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
11578 };
11579
11580 pub use crate::natural::CapabilityStoreError;
11581
11582 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
11583
11584 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
11585 }
11586
11587 pub struct GetNext;
11588
11589 impl ::fidl_next::Method for GetNext {
11590 const ORDINAL: u64 = 1511164556663256527;
11591 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11592 ::fidl_next::protocol::Flexibility::Flexible;
11593
11594 type Protocol = crate::DictionaryEnumerateIterator;
11595
11596 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
11597 }
11598
11599 impl ::fidl_next::TwoWayMethod for GetNext {
11600 type Response = ::fidl_next::WireFlexibleResult<
11601 'static,
11602 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
11603 crate::wire::CapabilityStoreError,
11604 >;
11605 }
11606
11607 impl<___R> ::fidl_next::Respond<___R> for GetNext {
11608 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11609
11610 fn respond(response: ___R) -> Self::Output {
11611 ::fidl_next::FlexibleResult::Ok(response)
11612 }
11613 }
11614
11615 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
11616 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11617
11618 fn respond_err(response: ___R) -> Self::Output {
11619 ::fidl_next::FlexibleResult::Err(response)
11620 }
11621 }
11622
11623 mod ___detail {
11624 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
11625 where
11626 ___T: ::fidl_next::Transport,
11627 {
11628 type Client = DictionaryEnumerateIteratorClient<___T>;
11629 type Server = DictionaryEnumerateIteratorServer<___T>;
11630 }
11631
11632 #[repr(transparent)]
11634 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
11635 #[allow(dead_code)]
11636 client: ::fidl_next::protocol::Client<___T>,
11637 }
11638
11639 impl<___T> DictionaryEnumerateIteratorClient<___T>
11640 where
11641 ___T: ::fidl_next::Transport,
11642 {
11643 #[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"]
11644 pub fn get_next(
11645 &self,
11646
11647 start_id: impl ::fidl_next::Encode<
11648 ::fidl_next::WireU64,
11649 <___T as ::fidl_next::Transport>::SendBuffer,
11650 >,
11651
11652 limit: impl ::fidl_next::Encode<
11653 ::fidl_next::WireU32,
11654 <___T as ::fidl_next::Transport>::SendBuffer,
11655 >,
11656 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11657 where
11658 <___T as ::fidl_next::Transport>::SendBuffer:
11659 ::fidl_next::encoder::InternalHandleEncoder,
11660 {
11661 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
11662 start_id,
11663
11664 limit,
11665 })
11666 }
11667
11668 #[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"]
11669 pub fn get_next_with<___R>(
11670 &self,
11671 request: ___R,
11672 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11673 where
11674 ___R: ::fidl_next::Encode<
11675 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
11676 <___T as ::fidl_next::Transport>::SendBuffer,
11677 >,
11678 {
11679 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11680 1511164556663256527,
11681 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
11682 request,
11683 ))
11684 }
11685 }
11686
11687 #[repr(transparent)]
11689 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
11690 server: ::fidl_next::protocol::Server<___T>,
11691 }
11692
11693 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11694 }
11695}
11696
11697pub trait DictionaryEnumerateIteratorClientHandler<
11701 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11702 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11703>
11704{
11705 fn on_unknown_interaction(
11706 &mut self,
11707 ordinal: u64,
11708 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11709 ::core::future::ready(())
11710 }
11711}
11712
11713impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11714where
11715 ___T: ::fidl_next::Transport,
11716{
11717 async fn on_unknown_interaction(&mut self, _: u64) {}
11718}
11719
11720impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
11721where
11722 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
11723 ___T: ::fidl_next::Transport,
11724{
11725 async fn on_event(
11726 handler: &mut ___H,
11727 ordinal: u64,
11728 flexibility: ::fidl_next::protocol::Flexibility,
11729 buffer: ___T::RecvBuffer,
11730 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11731 match ordinal {
11732 ordinal => {
11733 handler.on_unknown_interaction(ordinal).await;
11734 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11735 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11736 } else {
11737 Ok(())
11738 }
11739 }
11740 }
11741 }
11742}
11743
11744pub trait DictionaryEnumerateIteratorServerHandler<
11748 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11749 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11750>
11751{
11752 #[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"]
11753 fn get_next(
11754 &mut self,
11755
11756 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
11757
11758 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
11759 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11760
11761 fn on_unknown_interaction(
11762 &mut self,
11763 ordinal: u64,
11764 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11765 ::core::future::ready(())
11766 }
11767}
11768
11769impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
11770where
11771 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
11772 ___T: ::fidl_next::Transport,
11773 <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
11774 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11775{
11776 async fn on_one_way(
11777 handler: &mut ___H,
11778 ordinal: u64,
11779 flexibility: ::fidl_next::protocol::Flexibility,
11780 buffer: ___T::RecvBuffer,
11781 ) -> ::core::result::Result<
11782 (),
11783 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11784 > {
11785 match ordinal {
11786 ordinal => {
11787 handler.on_unknown_interaction(ordinal).await;
11788 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11789 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11790 } else {
11791 Ok(())
11792 }
11793 }
11794 }
11795 }
11796
11797 async fn on_two_way(
11798 handler: &mut ___H,
11799 ordinal: u64,
11800 flexibility: ::fidl_next::protocol::Flexibility,
11801 buffer: ___T::RecvBuffer,
11802 responder: ::fidl_next::protocol::Responder<___T>,
11803 ) -> ::core::result::Result<
11804 (),
11805 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11806 > {
11807 match ordinal {
11808 1511164556663256527 => {
11809 let responder = ::fidl_next::Responder::from_untyped(responder);
11810
11811 match ::fidl_next::DecoderExt::decode(buffer) {
11812 Ok(decoded) => {
11813 handler
11814 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
11815 .await;
11816 Ok(())
11817 }
11818 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11819 ordinal: 1511164556663256527,
11820 error,
11821 }),
11822 }
11823 }
11824
11825 ordinal => {
11826 handler.on_unknown_interaction(ordinal).await;
11827 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11828 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11829 } else {
11830 responder
11831 .respond(
11832 ordinal,
11833 flexibility,
11834 ::fidl_next::Flexible::<()>::FrameworkErr(
11835 ::fidl_next::FrameworkError::UnknownMethod,
11836 ),
11837 )
11838 .expect("encoding a framework error should never fail")
11839 .await?;
11840 Ok(())
11841 }
11842 }
11843 }
11844 }
11845}
11846
11847#[derive(PartialEq, Debug)]
11849pub struct DictionaryKeysIterator;
11850
11851#[cfg(target_os = "fuchsia")]
11852impl ::fidl_next::HasTransport for DictionaryKeysIterator {
11853 type Transport = ::fidl_next::fuchsia::zx::Channel;
11854}
11855
11856pub mod dictionary_keys_iterator {
11857 pub mod prelude {
11858 pub use crate::{
11859 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
11860 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
11861 };
11862
11863 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
11864 }
11865
11866 pub struct GetNext;
11867
11868 impl ::fidl_next::Method for GetNext {
11869 const ORDINAL: u64 = 4987781442555247955;
11870 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11871 ::fidl_next::protocol::Flexibility::Flexible;
11872
11873 type Protocol = crate::DictionaryKeysIterator;
11874
11875 type Request = ();
11876 }
11877
11878 impl ::fidl_next::TwoWayMethod for GetNext {
11879 type Response = ::fidl_next::WireFlexible<
11880 'static,
11881 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
11882 >;
11883 }
11884
11885 impl<___R> ::fidl_next::Respond<___R> for GetNext {
11886 type Output =
11887 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
11888
11889 fn respond(response: ___R) -> Self::Output {
11890 ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
11891 keys: response,
11892 })
11893 }
11894 }
11895
11896 mod ___detail {
11897 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
11898 where
11899 ___T: ::fidl_next::Transport,
11900 {
11901 type Client = DictionaryKeysIteratorClient<___T>;
11902 type Server = DictionaryKeysIteratorServer<___T>;
11903 }
11904
11905 #[repr(transparent)]
11907 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
11908 #[allow(dead_code)]
11909 client: ::fidl_next::protocol::Client<___T>,
11910 }
11911
11912 impl<___T> DictionaryKeysIteratorClient<___T>
11913 where
11914 ___T: ::fidl_next::Transport,
11915 {
11916 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
11917 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11918 4987781442555247955,
11919 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
11920 (),
11921 ))
11922 }
11923 }
11924
11925 #[repr(transparent)]
11927 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
11928 server: ::fidl_next::protocol::Server<___T>,
11929 }
11930
11931 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11932 }
11933}
11934
11935pub trait DictionaryKeysIteratorClientHandler<
11939 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11940 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11941>
11942{
11943 fn on_unknown_interaction(
11944 &mut self,
11945 ordinal: u64,
11946 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11947 ::core::future::ready(())
11948 }
11949}
11950
11951impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11952where
11953 ___T: ::fidl_next::Transport,
11954{
11955 async fn on_unknown_interaction(&mut self, _: u64) {}
11956}
11957
11958impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
11959where
11960 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
11961 ___T: ::fidl_next::Transport,
11962{
11963 async fn on_event(
11964 handler: &mut ___H,
11965 ordinal: u64,
11966 flexibility: ::fidl_next::protocol::Flexibility,
11967 buffer: ___T::RecvBuffer,
11968 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11969 match ordinal {
11970 ordinal => {
11971 handler.on_unknown_interaction(ordinal).await;
11972 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11973 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11974 } else {
11975 Ok(())
11976 }
11977 }
11978 }
11979 }
11980}
11981
11982pub trait DictionaryKeysIteratorServerHandler<
11986 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11987 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11988>
11989{
11990 fn get_next(
11991 &mut self,
11992
11993 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
11994 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11995
11996 fn on_unknown_interaction(
11997 &mut self,
11998 ordinal: u64,
11999 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12000 ::core::future::ready(())
12001 }
12002}
12003
12004impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
12005where
12006 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
12007 ___T: ::fidl_next::Transport,
12008{
12009 async fn on_one_way(
12010 handler: &mut ___H,
12011 ordinal: u64,
12012 flexibility: ::fidl_next::protocol::Flexibility,
12013 buffer: ___T::RecvBuffer,
12014 ) -> ::core::result::Result<
12015 (),
12016 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12017 > {
12018 match ordinal {
12019 ordinal => {
12020 handler.on_unknown_interaction(ordinal).await;
12021 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12022 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12023 } else {
12024 Ok(())
12025 }
12026 }
12027 }
12028 }
12029
12030 async fn on_two_way(
12031 handler: &mut ___H,
12032 ordinal: u64,
12033 flexibility: ::fidl_next::protocol::Flexibility,
12034 buffer: ___T::RecvBuffer,
12035 responder: ::fidl_next::protocol::Responder<___T>,
12036 ) -> ::core::result::Result<
12037 (),
12038 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12039 > {
12040 match ordinal {
12041 4987781442555247955 => {
12042 let responder = ::fidl_next::Responder::from_untyped(responder);
12043
12044 handler.get_next(responder).await;
12045 Ok(())
12046 }
12047
12048 ordinal => {
12049 handler.on_unknown_interaction(ordinal).await;
12050 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12051 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12052 } else {
12053 responder
12054 .respond(
12055 ordinal,
12056 flexibility,
12057 ::fidl_next::Flexible::<()>::FrameworkErr(
12058 ::fidl_next::FrameworkError::UnknownMethod,
12059 ),
12060 )
12061 .expect("encoding a framework error should never fail")
12062 .await?;
12063 Ok(())
12064 }
12065 }
12066 }
12067 }
12068}
12069
12070#[derive(PartialEq, Debug)]
12072pub struct DictionaryRouter;
12073
12074impl ::fidl_next::Discoverable for DictionaryRouter {
12075 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
12076}
12077
12078#[cfg(target_os = "fuchsia")]
12079impl ::fidl_next::HasTransport for DictionaryRouter {
12080 type Transport = ::fidl_next::fuchsia::zx::Channel;
12081}
12082
12083pub mod dictionary_router {
12084 pub mod prelude {
12085 pub use crate::{
12086 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
12087 dictionary_router,
12088 };
12089
12090 pub use crate::natural::DictionaryRouterRouteResponse;
12091
12092 pub use crate::natural::RouteRequest;
12093
12094 pub use crate::natural::RouterError;
12095 }
12096
12097 pub struct Route;
12098
12099 impl ::fidl_next::Method for Route {
12100 const ORDINAL: u64 = 8164012099375978399;
12101 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12102 ::fidl_next::protocol::Flexibility::Flexible;
12103
12104 type Protocol = crate::DictionaryRouter;
12105
12106 type Request = crate::wire::RouteRequest<'static>;
12107 }
12108
12109 impl ::fidl_next::TwoWayMethod for Route {
12110 type Response = ::fidl_next::WireFlexibleResult<
12111 'static,
12112 crate::wire::DictionaryRouterRouteResponse,
12113 crate::wire::RouterError,
12114 >;
12115 }
12116
12117 impl<___R> ::fidl_next::Respond<___R> for Route {
12118 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12119
12120 fn respond(response: ___R) -> Self::Output {
12121 ::fidl_next::FlexibleResult::Ok(response)
12122 }
12123 }
12124
12125 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12126 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12127
12128 fn respond_err(response: ___R) -> Self::Output {
12129 ::fidl_next::FlexibleResult::Err(response)
12130 }
12131 }
12132
12133 mod ___detail {
12134 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
12135 where
12136 ___T: ::fidl_next::Transport,
12137 {
12138 type Client = DictionaryRouterClient<___T>;
12139 type Server = DictionaryRouterServer<___T>;
12140 }
12141
12142 #[repr(transparent)]
12144 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
12145 #[allow(dead_code)]
12146 client: ::fidl_next::protocol::Client<___T>,
12147 }
12148
12149 impl<___T> DictionaryRouterClient<___T>
12150 where
12151 ___T: ::fidl_next::Transport,
12152 {
12153 pub fn route_with<___R>(
12154 &self,
12155 request: ___R,
12156 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12157 where
12158 ___R: ::fidl_next::Encode<
12159 crate::wire::RouteRequest<'static>,
12160 <___T as ::fidl_next::Transport>::SendBuffer,
12161 >,
12162 {
12163 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12164 8164012099375978399,
12165 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12166 request,
12167 ))
12168 }
12169 }
12170
12171 #[repr(transparent)]
12173 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
12174 server: ::fidl_next::protocol::Server<___T>,
12175 }
12176
12177 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12178 }
12179}
12180
12181pub trait DictionaryRouterClientHandler<
12185 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12186 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12187>
12188{
12189 fn on_unknown_interaction(
12190 &mut self,
12191 ordinal: u64,
12192 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12193 ::core::future::ready(())
12194 }
12195}
12196
12197impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12198where
12199 ___T: ::fidl_next::Transport,
12200{
12201 async fn on_unknown_interaction(&mut self, _: u64) {}
12202}
12203
12204impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
12205where
12206 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
12207 ___T: ::fidl_next::Transport,
12208{
12209 async fn on_event(
12210 handler: &mut ___H,
12211 ordinal: u64,
12212 flexibility: ::fidl_next::protocol::Flexibility,
12213 buffer: ___T::RecvBuffer,
12214 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12215 match ordinal {
12216 ordinal => {
12217 handler.on_unknown_interaction(ordinal).await;
12218 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12219 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12220 } else {
12221 Ok(())
12222 }
12223 }
12224 }
12225 }
12226}
12227
12228pub trait DictionaryRouterServerHandler<
12232 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12233 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12234>
12235{
12236 fn route(
12237 &mut self,
12238
12239 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
12240
12241 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
12242 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12243
12244 fn on_unknown_interaction(
12245 &mut self,
12246 ordinal: u64,
12247 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12248 ::core::future::ready(())
12249 }
12250}
12251
12252impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
12253where
12254 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
12255 ___T: ::fidl_next::Transport,
12256 <dictionary_router::Route as ::fidl_next::Method>::Request:
12257 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12258{
12259 async fn on_one_way(
12260 handler: &mut ___H,
12261 ordinal: u64,
12262 flexibility: ::fidl_next::protocol::Flexibility,
12263 buffer: ___T::RecvBuffer,
12264 ) -> ::core::result::Result<
12265 (),
12266 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12267 > {
12268 match ordinal {
12269 ordinal => {
12270 handler.on_unknown_interaction(ordinal).await;
12271 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12272 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12273 } else {
12274 Ok(())
12275 }
12276 }
12277 }
12278 }
12279
12280 async fn on_two_way(
12281 handler: &mut ___H,
12282 ordinal: u64,
12283 flexibility: ::fidl_next::protocol::Flexibility,
12284 buffer: ___T::RecvBuffer,
12285 responder: ::fidl_next::protocol::Responder<___T>,
12286 ) -> ::core::result::Result<
12287 (),
12288 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12289 > {
12290 match ordinal {
12291 8164012099375978399 => {
12292 let responder = ::fidl_next::Responder::from_untyped(responder);
12293
12294 match ::fidl_next::DecoderExt::decode(buffer) {
12295 Ok(decoded) => {
12296 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12297 Ok(())
12298 }
12299 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12300 ordinal: 8164012099375978399,
12301 error,
12302 }),
12303 }
12304 }
12305
12306 ordinal => {
12307 handler.on_unknown_interaction(ordinal).await;
12308 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12309 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12310 } else {
12311 responder
12312 .respond(
12313 ordinal,
12314 flexibility,
12315 ::fidl_next::Flexible::<()>::FrameworkErr(
12316 ::fidl_next::FrameworkError::UnknownMethod,
12317 ),
12318 )
12319 .expect("encoding a framework error should never fail")
12320 .await?;
12321 Ok(())
12322 }
12323 }
12324 }
12325 }
12326}
12327
12328#[derive(PartialEq, Debug)]
12330pub struct DirConnectorRouter;
12331
12332impl ::fidl_next::Discoverable for DirConnectorRouter {
12333 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
12334}
12335
12336#[cfg(target_os = "fuchsia")]
12337impl ::fidl_next::HasTransport for DirConnectorRouter {
12338 type Transport = ::fidl_next::fuchsia::zx::Channel;
12339}
12340
12341pub mod dir_connector_router {
12342 pub mod prelude {
12343 pub use crate::{
12344 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
12345 dir_connector_router,
12346 };
12347
12348 pub use crate::natural::DirConnectorRouterRouteResponse;
12349
12350 pub use crate::natural::RouteRequest;
12351
12352 pub use crate::natural::RouterError;
12353 }
12354
12355 pub struct Route;
12356
12357 impl ::fidl_next::Method for Route {
12358 const ORDINAL: u64 = 972231070188342848;
12359 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12360 ::fidl_next::protocol::Flexibility::Flexible;
12361
12362 type Protocol = crate::DirConnectorRouter;
12363
12364 type Request = crate::wire::RouteRequest<'static>;
12365 }
12366
12367 impl ::fidl_next::TwoWayMethod for Route {
12368 type Response = ::fidl_next::WireFlexibleResult<
12369 'static,
12370 crate::wire::DirConnectorRouterRouteResponse,
12371 crate::wire::RouterError,
12372 >;
12373 }
12374
12375 impl<___R> ::fidl_next::Respond<___R> for Route {
12376 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12377
12378 fn respond(response: ___R) -> Self::Output {
12379 ::fidl_next::FlexibleResult::Ok(response)
12380 }
12381 }
12382
12383 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12384 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12385
12386 fn respond_err(response: ___R) -> Self::Output {
12387 ::fidl_next::FlexibleResult::Err(response)
12388 }
12389 }
12390
12391 mod ___detail {
12392 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
12393 where
12394 ___T: ::fidl_next::Transport,
12395 {
12396 type Client = DirConnectorRouterClient<___T>;
12397 type Server = DirConnectorRouterServer<___T>;
12398 }
12399
12400 #[repr(transparent)]
12402 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
12403 #[allow(dead_code)]
12404 client: ::fidl_next::protocol::Client<___T>,
12405 }
12406
12407 impl<___T> DirConnectorRouterClient<___T>
12408 where
12409 ___T: ::fidl_next::Transport,
12410 {
12411 pub fn route_with<___R>(
12412 &self,
12413 request: ___R,
12414 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12415 where
12416 ___R: ::fidl_next::Encode<
12417 crate::wire::RouteRequest<'static>,
12418 <___T as ::fidl_next::Transport>::SendBuffer,
12419 >,
12420 {
12421 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12422 972231070188342848,
12423 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12424 request,
12425 ))
12426 }
12427 }
12428
12429 #[repr(transparent)]
12431 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
12432 server: ::fidl_next::protocol::Server<___T>,
12433 }
12434
12435 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
12436 }
12437}
12438
12439pub trait DirConnectorRouterClientHandler<
12443 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12444 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12445>
12446{
12447 fn on_unknown_interaction(
12448 &mut self,
12449 ordinal: u64,
12450 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12451 ::core::future::ready(())
12452 }
12453}
12454
12455impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12456where
12457 ___T: ::fidl_next::Transport,
12458{
12459 async fn on_unknown_interaction(&mut self, _: u64) {}
12460}
12461
12462impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
12463where
12464 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
12465 ___T: ::fidl_next::Transport,
12466{
12467 async fn on_event(
12468 handler: &mut ___H,
12469 ordinal: u64,
12470 flexibility: ::fidl_next::protocol::Flexibility,
12471 buffer: ___T::RecvBuffer,
12472 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12473 match ordinal {
12474 ordinal => {
12475 handler.on_unknown_interaction(ordinal).await;
12476 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12477 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12478 } else {
12479 Ok(())
12480 }
12481 }
12482 }
12483 }
12484}
12485
12486pub trait DirConnectorRouterServerHandler<
12490 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12491 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12492>
12493{
12494 fn route(
12495 &mut self,
12496
12497 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
12498
12499 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
12500 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12501
12502 fn on_unknown_interaction(
12503 &mut self,
12504 ordinal: u64,
12505 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12506 ::core::future::ready(())
12507 }
12508}
12509
12510impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
12511where
12512 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
12513 ___T: ::fidl_next::Transport,
12514 <dir_connector_router::Route as ::fidl_next::Method>::Request:
12515 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12516{
12517 async fn on_one_way(
12518 handler: &mut ___H,
12519 ordinal: u64,
12520 flexibility: ::fidl_next::protocol::Flexibility,
12521 buffer: ___T::RecvBuffer,
12522 ) -> ::core::result::Result<
12523 (),
12524 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12525 > {
12526 match ordinal {
12527 ordinal => {
12528 handler.on_unknown_interaction(ordinal).await;
12529 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12530 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12531 } else {
12532 Ok(())
12533 }
12534 }
12535 }
12536 }
12537
12538 async fn on_two_way(
12539 handler: &mut ___H,
12540 ordinal: u64,
12541 flexibility: ::fidl_next::protocol::Flexibility,
12542 buffer: ___T::RecvBuffer,
12543 responder: ::fidl_next::protocol::Responder<___T>,
12544 ) -> ::core::result::Result<
12545 (),
12546 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12547 > {
12548 match ordinal {
12549 972231070188342848 => {
12550 let responder = ::fidl_next::Responder::from_untyped(responder);
12551
12552 match ::fidl_next::DecoderExt::decode(buffer) {
12553 Ok(decoded) => {
12554 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12555 Ok(())
12556 }
12557 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12558 ordinal: 972231070188342848,
12559 error,
12560 }),
12561 }
12562 }
12563
12564 ordinal => {
12565 handler.on_unknown_interaction(ordinal).await;
12566 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12567 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12568 } else {
12569 responder
12570 .respond(
12571 ordinal,
12572 flexibility,
12573 ::fidl_next::Flexible::<()>::FrameworkErr(
12574 ::fidl_next::FrameworkError::UnknownMethod,
12575 ),
12576 )
12577 .expect("encoding a framework error should never fail")
12578 .await?;
12579 Ok(())
12580 }
12581 }
12582 }
12583 }
12584}
12585
12586#[derive(PartialEq, Debug)]
12588pub struct DirEntryRouter;
12589
12590impl ::fidl_next::Discoverable for DirEntryRouter {
12591 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
12592}
12593
12594#[cfg(target_os = "fuchsia")]
12595impl ::fidl_next::HasTransport for DirEntryRouter {
12596 type Transport = ::fidl_next::fuchsia::zx::Channel;
12597}
12598
12599pub mod dir_entry_router {
12600 pub mod prelude {
12601 pub use crate::{
12602 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
12603 dir_entry_router,
12604 };
12605
12606 pub use crate::natural::DirEntryRouterRouteResponse;
12607
12608 pub use crate::natural::RouteRequest;
12609
12610 pub use crate::natural::RouterError;
12611 }
12612
12613 pub struct Route;
12614
12615 impl ::fidl_next::Method for Route {
12616 const ORDINAL: u64 = 1929392218567642066;
12617 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12618 ::fidl_next::protocol::Flexibility::Flexible;
12619
12620 type Protocol = crate::DirEntryRouter;
12621
12622 type Request = crate::wire::RouteRequest<'static>;
12623 }
12624
12625 impl ::fidl_next::TwoWayMethod for Route {
12626 type Response = ::fidl_next::WireFlexibleResult<
12627 'static,
12628 crate::wire::DirEntryRouterRouteResponse,
12629 crate::wire::RouterError,
12630 >;
12631 }
12632
12633 impl<___R> ::fidl_next::Respond<___R> for Route {
12634 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12635
12636 fn respond(response: ___R) -> Self::Output {
12637 ::fidl_next::FlexibleResult::Ok(response)
12638 }
12639 }
12640
12641 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12642 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12643
12644 fn respond_err(response: ___R) -> Self::Output {
12645 ::fidl_next::FlexibleResult::Err(response)
12646 }
12647 }
12648
12649 mod ___detail {
12650 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
12651 where
12652 ___T: ::fidl_next::Transport,
12653 {
12654 type Client = DirEntryRouterClient<___T>;
12655 type Server = DirEntryRouterServer<___T>;
12656 }
12657
12658 #[repr(transparent)]
12660 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
12661 #[allow(dead_code)]
12662 client: ::fidl_next::protocol::Client<___T>,
12663 }
12664
12665 impl<___T> DirEntryRouterClient<___T>
12666 where
12667 ___T: ::fidl_next::Transport,
12668 {
12669 pub fn route_with<___R>(
12670 &self,
12671 request: ___R,
12672 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12673 where
12674 ___R: ::fidl_next::Encode<
12675 crate::wire::RouteRequest<'static>,
12676 <___T as ::fidl_next::Transport>::SendBuffer,
12677 >,
12678 {
12679 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12680 1929392218567642066,
12681 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12682 request,
12683 ))
12684 }
12685 }
12686
12687 #[repr(transparent)]
12689 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
12690 server: ::fidl_next::protocol::Server<___T>,
12691 }
12692
12693 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12694 }
12695}
12696
12697pub trait DirEntryRouterClientHandler<
12701 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12702 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12703>
12704{
12705 fn on_unknown_interaction(
12706 &mut self,
12707 ordinal: u64,
12708 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12709 ::core::future::ready(())
12710 }
12711}
12712
12713impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12714where
12715 ___T: ::fidl_next::Transport,
12716{
12717 async fn on_unknown_interaction(&mut self, _: u64) {}
12718}
12719
12720impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
12721where
12722 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
12723 ___T: ::fidl_next::Transport,
12724{
12725 async fn on_event(
12726 handler: &mut ___H,
12727 ordinal: u64,
12728 flexibility: ::fidl_next::protocol::Flexibility,
12729 buffer: ___T::RecvBuffer,
12730 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12731 match ordinal {
12732 ordinal => {
12733 handler.on_unknown_interaction(ordinal).await;
12734 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12735 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12736 } else {
12737 Ok(())
12738 }
12739 }
12740 }
12741 }
12742}
12743
12744pub trait DirEntryRouterServerHandler<
12748 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12749 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12750>
12751{
12752 fn route(
12753 &mut self,
12754
12755 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
12756
12757 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
12758 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12759
12760 fn on_unknown_interaction(
12761 &mut self,
12762 ordinal: u64,
12763 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12764 ::core::future::ready(())
12765 }
12766}
12767
12768impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
12769where
12770 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
12771 ___T: ::fidl_next::Transport,
12772 <dir_entry_router::Route as ::fidl_next::Method>::Request:
12773 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12774{
12775 async fn on_one_way(
12776 handler: &mut ___H,
12777 ordinal: u64,
12778 flexibility: ::fidl_next::protocol::Flexibility,
12779 buffer: ___T::RecvBuffer,
12780 ) -> ::core::result::Result<
12781 (),
12782 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12783 > {
12784 match ordinal {
12785 ordinal => {
12786 handler.on_unknown_interaction(ordinal).await;
12787 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12788 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12789 } else {
12790 Ok(())
12791 }
12792 }
12793 }
12794 }
12795
12796 async fn on_two_way(
12797 handler: &mut ___H,
12798 ordinal: u64,
12799 flexibility: ::fidl_next::protocol::Flexibility,
12800 buffer: ___T::RecvBuffer,
12801 responder: ::fidl_next::protocol::Responder<___T>,
12802 ) -> ::core::result::Result<
12803 (),
12804 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12805 > {
12806 match ordinal {
12807 1929392218567642066 => {
12808 let responder = ::fidl_next::Responder::from_untyped(responder);
12809
12810 match ::fidl_next::DecoderExt::decode(buffer) {
12811 Ok(decoded) => {
12812 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12813 Ok(())
12814 }
12815 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12816 ordinal: 1929392218567642066,
12817 error,
12818 }),
12819 }
12820 }
12821
12822 ordinal => {
12823 handler.on_unknown_interaction(ordinal).await;
12824 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12825 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12826 } else {
12827 responder
12828 .respond(
12829 ordinal,
12830 flexibility,
12831 ::fidl_next::Flexible::<()>::FrameworkErr(
12832 ::fidl_next::FrameworkError::UnknownMethod,
12833 ),
12834 )
12835 .expect("encoding a framework error should never fail")
12836 .await?;
12837 Ok(())
12838 }
12839 }
12840 }
12841 }
12842}
12843
12844#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
12846#[derive(PartialEq, Debug)]
12847pub struct DirReceiver;
12848
12849impl ::fidl_next::Discoverable for DirReceiver {
12850 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
12851}
12852
12853#[cfg(target_os = "fuchsia")]
12854impl ::fidl_next::HasTransport for DirReceiver {
12855 type Transport = ::fidl_next::fuchsia::zx::Channel;
12856}
12857
12858pub mod dir_receiver {
12859 pub mod prelude {
12860 pub use crate::{
12861 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
12862 };
12863
12864 pub use crate::natural::DirReceiverReceiveRequest;
12865 }
12866
12867 pub struct Receive;
12868
12869 impl ::fidl_next::Method for Receive {
12870 const ORDINAL: u64 = 926684461087488948;
12871 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12872 ::fidl_next::protocol::Flexibility::Flexible;
12873
12874 type Protocol = crate::DirReceiver;
12875
12876 type Request = crate::wire::DirReceiverReceiveRequest<'static>;
12877 }
12878
12879 mod ___detail {
12880 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
12881 where
12882 ___T: ::fidl_next::Transport,
12883 {
12884 type Client = DirReceiverClient<___T>;
12885 type Server = DirReceiverServer<___T>;
12886 }
12887
12888 #[repr(transparent)]
12890 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
12891 #[allow(dead_code)]
12892 client: ::fidl_next::protocol::Client<___T>,
12893 }
12894
12895 impl<___T> DirReceiverClient<___T>
12896 where
12897 ___T: ::fidl_next::Transport,
12898 {
12899 #[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"]
12900 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
12901 where
12902 ___R: ::fidl_next::Encode<
12903 crate::wire::DirReceiverReceiveRequest<'static>,
12904 <___T as ::fidl_next::Transport>::SendBuffer,
12905 >,
12906 {
12907 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
12908 926684461087488948,
12909 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
12910 request,
12911 ))
12912 }
12913 }
12914
12915 #[repr(transparent)]
12917 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
12918 server: ::fidl_next::protocol::Server<___T>,
12919 }
12920
12921 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
12922 }
12923}
12924
12925pub trait DirReceiverClientHandler<
12929 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12930 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12931>
12932{
12933 fn on_unknown_interaction(
12934 &mut self,
12935 ordinal: u64,
12936 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12937 ::core::future::ready(())
12938 }
12939}
12940
12941impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
12942where
12943 ___T: ::fidl_next::Transport,
12944{
12945 async fn on_unknown_interaction(&mut self, _: u64) {}
12946}
12947
12948impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
12949where
12950 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
12951 ___T: ::fidl_next::Transport,
12952{
12953 async fn on_event(
12954 handler: &mut ___H,
12955 ordinal: u64,
12956 flexibility: ::fidl_next::protocol::Flexibility,
12957 buffer: ___T::RecvBuffer,
12958 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12959 match ordinal {
12960 ordinal => {
12961 handler.on_unknown_interaction(ordinal).await;
12962 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12963 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12964 } else {
12965 Ok(())
12966 }
12967 }
12968 }
12969 }
12970}
12971
12972pub trait DirReceiverServerHandler<
12976 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12977 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12978>
12979{
12980 #[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"]
12981 fn receive(
12982 &mut self,
12983
12984 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
12985 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12986
12987 fn on_unknown_interaction(
12988 &mut self,
12989 ordinal: u64,
12990 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12991 ::core::future::ready(())
12992 }
12993}
12994
12995impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
12996where
12997 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
12998 ___T: ::fidl_next::Transport,
12999 <dir_receiver::Receive as ::fidl_next::Method>::Request:
13000 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13001{
13002 async fn on_one_way(
13003 handler: &mut ___H,
13004 ordinal: u64,
13005 flexibility: ::fidl_next::protocol::Flexibility,
13006 buffer: ___T::RecvBuffer,
13007 ) -> ::core::result::Result<
13008 (),
13009 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13010 > {
13011 match ordinal {
13012 926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
13013 Ok(decoded) => {
13014 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
13015 Ok(())
13016 }
13017 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13018 ordinal: 926684461087488948,
13019 error,
13020 }),
13021 },
13022
13023 ordinal => {
13024 handler.on_unknown_interaction(ordinal).await;
13025 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13026 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13027 } else {
13028 Ok(())
13029 }
13030 }
13031 }
13032 }
13033
13034 async fn on_two_way(
13035 handler: &mut ___H,
13036 ordinal: u64,
13037 flexibility: ::fidl_next::protocol::Flexibility,
13038 buffer: ___T::RecvBuffer,
13039 responder: ::fidl_next::protocol::Responder<___T>,
13040 ) -> ::core::result::Result<
13041 (),
13042 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13043 > {
13044 match ordinal {
13045 ordinal => {
13046 handler.on_unknown_interaction(ordinal).await;
13047 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13048 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13049 } else {
13050 responder
13051 .respond(
13052 ordinal,
13053 flexibility,
13054 ::fidl_next::Flexible::<()>::FrameworkErr(
13055 ::fidl_next::FrameworkError::UnknownMethod,
13056 ),
13057 )
13058 .expect("encoding a framework error should never fail")
13059 .await?;
13060 Ok(())
13061 }
13062 }
13063 }
13064 }
13065}
13066
13067#[derive(PartialEq, Debug)]
13069pub struct DirectoryRouter;
13070
13071impl ::fidl_next::Discoverable for DirectoryRouter {
13072 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
13073}
13074
13075#[cfg(target_os = "fuchsia")]
13076impl ::fidl_next::HasTransport for DirectoryRouter {
13077 type Transport = ::fidl_next::fuchsia::zx::Channel;
13078}
13079
13080pub mod directory_router {
13081 pub mod prelude {
13082 pub use crate::{
13083 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
13084 directory_router,
13085 };
13086
13087 pub use crate::natural::DirectoryRouterRouteResponse;
13088
13089 pub use crate::natural::RouteRequest;
13090
13091 pub use crate::natural::RouterError;
13092 }
13093
13094 pub struct Route;
13095
13096 impl ::fidl_next::Method for Route {
13097 const ORDINAL: u64 = 7510716014181158689;
13098 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13099 ::fidl_next::protocol::Flexibility::Flexible;
13100
13101 type Protocol = crate::DirectoryRouter;
13102
13103 type Request = crate::wire::RouteRequest<'static>;
13104 }
13105
13106 impl ::fidl_next::TwoWayMethod for Route {
13107 type Response = ::fidl_next::WireFlexibleResult<
13108 'static,
13109 crate::wire::DirectoryRouterRouteResponse,
13110 crate::wire::RouterError,
13111 >;
13112 }
13113
13114 impl<___R> ::fidl_next::Respond<___R> for Route {
13115 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13116
13117 fn respond(response: ___R) -> Self::Output {
13118 ::fidl_next::FlexibleResult::Ok(response)
13119 }
13120 }
13121
13122 impl<___R> ::fidl_next::RespondErr<___R> for Route {
13123 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13124
13125 fn respond_err(response: ___R) -> Self::Output {
13126 ::fidl_next::FlexibleResult::Err(response)
13127 }
13128 }
13129
13130 mod ___detail {
13131 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
13132 where
13133 ___T: ::fidl_next::Transport,
13134 {
13135 type Client = DirectoryRouterClient<___T>;
13136 type Server = DirectoryRouterServer<___T>;
13137 }
13138
13139 #[repr(transparent)]
13141 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
13142 #[allow(dead_code)]
13143 client: ::fidl_next::protocol::Client<___T>,
13144 }
13145
13146 impl<___T> DirectoryRouterClient<___T>
13147 where
13148 ___T: ::fidl_next::Transport,
13149 {
13150 pub fn route_with<___R>(
13151 &self,
13152 request: ___R,
13153 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13154 where
13155 ___R: ::fidl_next::Encode<
13156 crate::wire::RouteRequest<'static>,
13157 <___T as ::fidl_next::Transport>::SendBuffer,
13158 >,
13159 {
13160 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13161 7510716014181158689,
13162 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
13163 request,
13164 ))
13165 }
13166 }
13167
13168 #[repr(transparent)]
13170 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
13171 server: ::fidl_next::protocol::Server<___T>,
13172 }
13173
13174 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
13175 }
13176}
13177
13178pub trait DirectoryRouterClientHandler<
13182 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13183 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13184>
13185{
13186 fn on_unknown_interaction(
13187 &mut self,
13188 ordinal: u64,
13189 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13190 ::core::future::ready(())
13191 }
13192}
13193
13194impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
13195where
13196 ___T: ::fidl_next::Transport,
13197{
13198 async fn on_unknown_interaction(&mut self, _: u64) {}
13199}
13200
13201impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
13202where
13203 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
13204 ___T: ::fidl_next::Transport,
13205{
13206 async fn on_event(
13207 handler: &mut ___H,
13208 ordinal: u64,
13209 flexibility: ::fidl_next::protocol::Flexibility,
13210 buffer: ___T::RecvBuffer,
13211 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13212 match ordinal {
13213 ordinal => {
13214 handler.on_unknown_interaction(ordinal).await;
13215 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13216 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13217 } else {
13218 Ok(())
13219 }
13220 }
13221 }
13222 }
13223}
13224
13225pub trait DirectoryRouterServerHandler<
13229 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13230 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13231>
13232{
13233 fn route(
13234 &mut self,
13235
13236 request: ::fidl_next::Request<directory_router::Route, ___T>,
13237
13238 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
13239 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13240
13241 fn on_unknown_interaction(
13242 &mut self,
13243 ordinal: u64,
13244 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13245 ::core::future::ready(())
13246 }
13247}
13248
13249impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
13250where
13251 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
13252 ___T: ::fidl_next::Transport,
13253 <directory_router::Route as ::fidl_next::Method>::Request:
13254 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13255{
13256 async fn on_one_way(
13257 handler: &mut ___H,
13258 ordinal: u64,
13259 flexibility: ::fidl_next::protocol::Flexibility,
13260 buffer: ___T::RecvBuffer,
13261 ) -> ::core::result::Result<
13262 (),
13263 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13264 > {
13265 match ordinal {
13266 ordinal => {
13267 handler.on_unknown_interaction(ordinal).await;
13268 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13269 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13270 } else {
13271 Ok(())
13272 }
13273 }
13274 }
13275 }
13276
13277 async fn on_two_way(
13278 handler: &mut ___H,
13279 ordinal: u64,
13280 flexibility: ::fidl_next::protocol::Flexibility,
13281 buffer: ___T::RecvBuffer,
13282 responder: ::fidl_next::protocol::Responder<___T>,
13283 ) -> ::core::result::Result<
13284 (),
13285 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13286 > {
13287 match ordinal {
13288 7510716014181158689 => {
13289 let responder = ::fidl_next::Responder::from_untyped(responder);
13290
13291 match ::fidl_next::DecoderExt::decode(buffer) {
13292 Ok(decoded) => {
13293 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13294 Ok(())
13295 }
13296 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13297 ordinal: 7510716014181158689,
13298 error,
13299 }),
13300 }
13301 }
13302
13303 ordinal => {
13304 handler.on_unknown_interaction(ordinal).await;
13305 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13306 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13307 } else {
13308 responder
13309 .respond(
13310 ordinal,
13311 flexibility,
13312 ::fidl_next::Flexible::<()>::FrameworkErr(
13313 ::fidl_next::FrameworkError::UnknownMethod,
13314 ),
13315 )
13316 .expect("encoding a framework error should never fail")
13317 .await?;
13318 Ok(())
13319 }
13320 }
13321 }
13322 }
13323}
13324
13325#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
13327#[derive(PartialEq, Debug)]
13328pub struct Receiver;
13329
13330impl ::fidl_next::Discoverable for Receiver {
13331 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
13332}
13333
13334#[cfg(target_os = "fuchsia")]
13335impl ::fidl_next::HasTransport for Receiver {
13336 type Transport = ::fidl_next::fuchsia::zx::Channel;
13337}
13338
13339pub mod receiver {
13340 pub mod prelude {
13341 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
13342
13343 pub use crate::natural::ProtocolPayload;
13344 }
13345
13346 pub struct Receive;
13347
13348 impl ::fidl_next::Method for Receive {
13349 const ORDINAL: u64 = 340832707723008660;
13350 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13351 ::fidl_next::protocol::Flexibility::Flexible;
13352
13353 type Protocol = crate::Receiver;
13354
13355 type Request = crate::wire::ProtocolPayload;
13356 }
13357
13358 mod ___detail {
13359 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
13360 where
13361 ___T: ::fidl_next::Transport,
13362 {
13363 type Client = ReceiverClient<___T>;
13364 type Server = ReceiverServer<___T>;
13365 }
13366
13367 #[repr(transparent)]
13369 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
13370 #[allow(dead_code)]
13371 client: ::fidl_next::protocol::Client<___T>,
13372 }
13373
13374 impl<___T> ReceiverClient<___T>
13375 where
13376 ___T: ::fidl_next::Transport,
13377 {
13378 #[doc = " Sends a channel to this receiver.\n"]
13379 pub fn receive(
13380 &self,
13381
13382 channel: impl ::fidl_next::Encode<
13383 ::fidl_next::fuchsia::WireChannel,
13384 <___T as ::fidl_next::Transport>::SendBuffer,
13385 >,
13386 ) -> ::fidl_next::SendFuture<'_, ___T>
13387 where
13388 <___T as ::fidl_next::Transport>::SendBuffer:
13389 ::fidl_next::encoder::InternalHandleEncoder,
13390 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13391 {
13392 self.receive_with(crate::generic::ProtocolPayload { channel })
13393 }
13394
13395 #[doc = " Sends a channel to this receiver.\n"]
13396 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
13397 where
13398 ___R: ::fidl_next::Encode<
13399 crate::wire::ProtocolPayload,
13400 <___T as ::fidl_next::Transport>::SendBuffer,
13401 >,
13402 {
13403 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
13404 340832707723008660,
13405 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
13406 request,
13407 ))
13408 }
13409 }
13410
13411 #[repr(transparent)]
13413 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
13414 server: ::fidl_next::protocol::Server<___T>,
13415 }
13416
13417 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
13418 }
13419}
13420
13421pub trait ReceiverClientHandler<
13425 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13426 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13427>
13428{
13429 fn on_unknown_interaction(
13430 &mut self,
13431 ordinal: u64,
13432 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13433 ::core::future::ready(())
13434 }
13435}
13436
13437impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
13438where
13439 ___T: ::fidl_next::Transport,
13440{
13441 async fn on_unknown_interaction(&mut self, _: u64) {}
13442}
13443
13444impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
13445where
13446 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
13447 ___T: ::fidl_next::Transport,
13448{
13449 async fn on_event(
13450 handler: &mut ___H,
13451 ordinal: u64,
13452 flexibility: ::fidl_next::protocol::Flexibility,
13453 buffer: ___T::RecvBuffer,
13454 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13455 match ordinal {
13456 ordinal => {
13457 handler.on_unknown_interaction(ordinal).await;
13458 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13459 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13460 } else {
13461 Ok(())
13462 }
13463 }
13464 }
13465 }
13466}
13467
13468pub trait ReceiverServerHandler<
13472 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13473 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13474>
13475{
13476 #[doc = " Sends a channel to this receiver.\n"]
13477 fn receive(
13478 &mut self,
13479
13480 request: ::fidl_next::Request<receiver::Receive, ___T>,
13481 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13482
13483 fn on_unknown_interaction(
13484 &mut self,
13485 ordinal: u64,
13486 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13487 ::core::future::ready(())
13488 }
13489}
13490
13491impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
13492where
13493 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
13494 ___T: ::fidl_next::Transport,
13495 <receiver::Receive as ::fidl_next::Method>::Request:
13496 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13497{
13498 async fn on_one_way(
13499 handler: &mut ___H,
13500 ordinal: u64,
13501 flexibility: ::fidl_next::protocol::Flexibility,
13502 buffer: ___T::RecvBuffer,
13503 ) -> ::core::result::Result<
13504 (),
13505 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13506 > {
13507 match ordinal {
13508 340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
13509 Ok(decoded) => {
13510 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
13511 Ok(())
13512 }
13513 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13514 ordinal: 340832707723008660,
13515 error,
13516 }),
13517 },
13518
13519 ordinal => {
13520 handler.on_unknown_interaction(ordinal).await;
13521 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13522 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13523 } else {
13524 Ok(())
13525 }
13526 }
13527 }
13528 }
13529
13530 async fn on_two_way(
13531 handler: &mut ___H,
13532 ordinal: u64,
13533 flexibility: ::fidl_next::protocol::Flexibility,
13534 buffer: ___T::RecvBuffer,
13535 responder: ::fidl_next::protocol::Responder<___T>,
13536 ) -> ::core::result::Result<
13537 (),
13538 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13539 > {
13540 match ordinal {
13541 ordinal => {
13542 handler.on_unknown_interaction(ordinal).await;
13543 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13544 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13545 } else {
13546 responder
13547 .respond(
13548 ordinal,
13549 flexibility,
13550 ::fidl_next::Flexible::<()>::FrameworkErr(
13551 ::fidl_next::FrameworkError::UnknownMethod,
13552 ),
13553 )
13554 .expect("encoding a framework error should never fail")
13555 .await?;
13556 Ok(())
13557 }
13558 }
13559 }
13560 }
13561}
13562
13563pub use fidl_next_common_fuchsia_component_sandbox::*;
13564
13565pub mod compat {
13567
13568 pub use fidl_next_common_fuchsia_component_sandbox::compat::*;
13569
13570 impl ::fidl_next::CompatFrom<crate::DirConnector>
13571 for ::fidl_fuchsia_component_sandbox::DirConnector
13572 {
13573 #[inline]
13574 fn compat_from(value: crate::DirConnector) -> Self {
13575 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13576 }
13577 }
13578
13579 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
13580 for crate::DirConnector
13581 {
13582 #[inline]
13583 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
13584 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13585 }
13586 }
13587
13588 impl ::fidl_next::CompatFrom<crate::AggregateSource>
13589 for ::fidl_fuchsia_component_sandbox::AggregateSource
13590 {
13591 fn compat_from(value: crate::AggregateSource) -> Self {
13592 Self {
13593 dir_connector: ::fidl_next::CompatFrom::compat_from(value.dir_connector),
13594
13595 source_instance_filter: ::fidl_next::CompatFrom::compat_from(
13596 value.source_instance_filter,
13597 ),
13598
13599 renamed_instances: ::fidl_next::CompatFrom::compat_from(value.renamed_instances),
13600
13601 __source_breaking: ::fidl::marker::SourceBreaking,
13602 }
13603 }
13604 }
13605
13606 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::AggregateSource>
13607 for crate::AggregateSource
13608 {
13609 fn compat_from(value: ::fidl_fuchsia_component_sandbox::AggregateSource) -> Self {
13610 Self {
13611 dir_connector: ::fidl_next::CompatFrom::compat_from(value.dir_connector),
13612
13613 source_instance_filter: ::fidl_next::CompatFrom::compat_from(
13614 value.source_instance_filter,
13615 ),
13616
13617 renamed_instances: ::fidl_next::CompatFrom::compat_from(value.renamed_instances),
13618 }
13619 }
13620 }
13621
13622 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
13623 for ::fidl_fuchsia_component_sandbox::DictionaryRef
13624 {
13625 #[inline]
13626 fn compat_from(value: crate::DictionaryRef) -> Self {
13627 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13628 }
13629 }
13630
13631 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
13632 for crate::DictionaryRef
13633 {
13634 #[inline]
13635 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
13636 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13637 }
13638 }
13639
13640 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
13641 #[inline]
13642 fn compat_from(value: crate::Connector) -> Self {
13643 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13644 }
13645 }
13646
13647 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
13648 #[inline]
13649 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
13650 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13651 }
13652 }
13653
13654 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
13655 #[inline]
13656 fn compat_from(value: crate::DirEntry) -> Self {
13657 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13658 }
13659 }
13660
13661 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
13662 #[inline]
13663 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
13664 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
13665 }
13666 }
13667
13668 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
13669 fn compat_from(value: crate::Capability) -> Self {
13670 match value {
13671 crate::Capability::Unit(value) => {
13672 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
13673 }
13674
13675 crate::Capability::Handle(value) => {
13676 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
13677 }
13678
13679 crate::Capability::Data(value) => {
13680 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13681 }
13682
13683 crate::Capability::Dictionary(value) => {
13684 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
13685 }
13686
13687 crate::Capability::Connector(value) => {
13688 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
13689 }
13690
13691 crate::Capability::DirConnector(value) => {
13692 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
13693 }
13694
13695 crate::Capability::Directory(value) => {
13696 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
13697 }
13698
13699 crate::Capability::DirEntry(value) => {
13700 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13701 }
13702
13703 crate::Capability::ConnectorRouter(value) => {
13704 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
13705 }
13706
13707 crate::Capability::DictionaryRouter(value) => {
13708 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
13709 }
13710
13711 crate::Capability::DirEntryRouter(value) => {
13712 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
13713 }
13714
13715 crate::Capability::DataRouter(value) => {
13716 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
13717 }
13718
13719 crate::Capability::DirConnectorRouter(value) => {
13720 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
13721 }
13722
13723 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
13724 Self::__SourceBreaking { unknown_ordinal }
13725 }
13726 }
13727 }
13728 }
13729
13730 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
13731 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
13732 match value {
13733 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
13734 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
13735 }
13736
13737 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
13738 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
13739 }
13740
13741 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
13742 Self::Data(::fidl_next::CompatFrom::compat_from(value))
13743 }
13744
13745 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
13746 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
13747 }
13748
13749 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
13750 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
13751 }
13752
13753 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
13754 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
13755 }
13756
13757 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
13758 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
13759 }
13760
13761 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
13762 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
13763 }
13764
13765 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
13766 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
13767 }
13768
13769 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
13770 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
13771 }
13772
13773 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
13774 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
13775 }
13776
13777 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
13778 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
13779 }
13780
13781 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
13782 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
13783 }
13784
13785 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
13786 unknown_ordinal,
13787 } => Self::UnknownOrdinal_(unknown_ordinal),
13788 }
13789 }
13790 }
13791
13792 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
13793 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
13794 {
13795 #[inline]
13796 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
13797 Self {
13798 id: ::fidl_next::CompatFrom::compat_from(value.id),
13799
13800 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13801 }
13802 }
13803 }
13804
13805 impl
13806 ::fidl_next::CompatFrom<
13807 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
13808 > for crate::CapabilityStoreConnectorCreateRequest
13809 {
13810 #[inline]
13811 fn compat_from(
13812 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
13813 ) -> Self {
13814 Self {
13815 id: ::fidl_next::CompatFrom::compat_from(value.id),
13816
13817 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13818 }
13819 }
13820 }
13821
13822 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
13823 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
13824 {
13825 #[inline]
13826 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
13827 Self {
13828 id: ::fidl_next::CompatFrom::compat_from(value.id),
13829
13830 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13831 }
13832 }
13833 }
13834
13835 impl
13836 ::fidl_next::CompatFrom<
13837 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
13838 > for crate::CapabilityStoreConnectorOpenRequest
13839 {
13840 #[inline]
13841 fn compat_from(
13842 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
13843 ) -> Self {
13844 Self {
13845 id: ::fidl_next::CompatFrom::compat_from(value.id),
13846
13847 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13848 }
13849 }
13850 }
13851
13852 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
13853 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
13854 {
13855 #[inline]
13856 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
13857 Self {
13858 id: ::fidl_next::CompatFrom::compat_from(value.id),
13859
13860 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13861 }
13862 }
13863 }
13864
13865 impl
13866 ::fidl_next::CompatFrom<
13867 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13868 > for crate::CapabilityStoreDirConnectorCreateRequest
13869 {
13870 #[inline]
13871 fn compat_from(
13872 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
13873 ) -> Self {
13874 Self {
13875 id: ::fidl_next::CompatFrom::compat_from(value.id),
13876
13877 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
13878 }
13879 }
13880 }
13881
13882 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
13883 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
13884 {
13885 #[inline]
13886 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
13887 Self {
13888 id: ::fidl_next::CompatFrom::compat_from(value.id),
13889
13890 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
13891 }
13892 }
13893 }
13894
13895 impl
13896 ::fidl_next::CompatFrom<
13897 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
13898 > for crate::CapabilityStoreDictionaryLegacyImportRequest
13899 {
13900 #[inline]
13901 fn compat_from(
13902 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
13903 ) -> Self {
13904 Self {
13905 id: ::fidl_next::CompatFrom::compat_from(value.id),
13906
13907 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
13908 }
13909 }
13910 }
13911
13912 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
13913 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
13914 {
13915 #[inline]
13916 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
13917 Self {
13918 id: ::fidl_next::CompatFrom::compat_from(value.id),
13919
13920 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13921 }
13922 }
13923 }
13924
13925 impl
13926 ::fidl_next::CompatFrom<
13927 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
13928 > for crate::CapabilityStoreDictionaryLegacyExportRequest
13929 {
13930 #[inline]
13931 fn compat_from(
13932 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
13933 ) -> Self {
13934 Self {
13935 id: ::fidl_next::CompatFrom::compat_from(value.id),
13936
13937 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
13938 }
13939 }
13940 }
13941
13942 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
13943 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
13944 {
13945 #[inline]
13946 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
13947 Self {
13948 id: ::fidl_next::CompatFrom::compat_from(value.id),
13949
13950 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13951 }
13952 }
13953 }
13954
13955 impl
13956 ::fidl_next::CompatFrom<
13957 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
13958 > for crate::CapabilityStoreDictionaryKeysRequest
13959 {
13960 #[inline]
13961 fn compat_from(
13962 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
13963 ) -> Self {
13964 Self {
13965 id: ::fidl_next::CompatFrom::compat_from(value.id),
13966
13967 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13968 }
13969 }
13970 }
13971
13972 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
13973 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
13974 {
13975 #[inline]
13976 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
13977 Self {
13978 id: ::fidl_next::CompatFrom::compat_from(value.id),
13979
13980 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13981 }
13982 }
13983 }
13984
13985 impl
13986 ::fidl_next::CompatFrom<
13987 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
13988 > for crate::CapabilityStoreDictionaryEnumerateRequest
13989 {
13990 #[inline]
13991 fn compat_from(
13992 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
13993 ) -> Self {
13994 Self {
13995 id: ::fidl_next::CompatFrom::compat_from(value.id),
13996
13997 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
13998 }
13999 }
14000 }
14001
14002 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
14003 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
14004 {
14005 #[inline]
14006 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
14007 Self {
14008 id: ::fidl_next::CompatFrom::compat_from(value.id),
14009
14010 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14011 }
14012 }
14013 }
14014
14015 impl
14016 ::fidl_next::CompatFrom<
14017 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
14018 > for crate::CapabilityStoreDictionaryDrainRequest
14019 {
14020 #[inline]
14021 fn compat_from(
14022 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
14023 ) -> Self {
14024 Self {
14025 id: ::fidl_next::CompatFrom::compat_from(value.id),
14026
14027 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14028 }
14029 }
14030 }
14031
14032 impl ::fidl_next::CompatFrom<crate::CapabilityStoreCreateServiceAggregateRequest>
14033 for ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest
14034 {
14035 #[inline]
14036 fn compat_from(value: crate::CapabilityStoreCreateServiceAggregateRequest) -> Self {
14037 Self { sources: ::fidl_next::CompatFrom::compat_from(value.sources) }
14038 }
14039 }
14040
14041 impl
14042 ::fidl_next::CompatFrom<
14043 ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest,
14044 > for crate::CapabilityStoreCreateServiceAggregateRequest
14045 {
14046 #[inline]
14047 fn compat_from(
14048 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest,
14049 ) -> Self {
14050 Self { sources: ::fidl_next::CompatFrom::compat_from(value.sources) }
14051 }
14052 }
14053
14054 impl ::fidl_next::CompatFrom<crate::CapabilityStoreCreateServiceAggregateResponse>
14055 for ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse
14056 {
14057 #[inline]
14058 fn compat_from(value: crate::CapabilityStoreCreateServiceAggregateResponse) -> Self {
14059 Self {
14060 aggregate_dir_connector: ::fidl_next::CompatFrom::compat_from(
14061 value.aggregate_dir_connector,
14062 ),
14063 }
14064 }
14065 }
14066
14067 impl
14068 ::fidl_next::CompatFrom<
14069 ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse,
14070 > for crate::CapabilityStoreCreateServiceAggregateResponse
14071 {
14072 #[inline]
14073 fn compat_from(
14074 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse,
14075 ) -> Self {
14076 Self {
14077 aggregate_dir_connector: ::fidl_next::CompatFrom::compat_from(
14078 value.aggregate_dir_connector,
14079 ),
14080 }
14081 }
14082 }
14083
14084 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
14085 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
14086 {
14087 #[inline]
14088 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
14089 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
14090 }
14091 }
14092
14093 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
14094 for crate::CapabilityStoreExportResponse
14095 {
14096 #[inline]
14097 fn compat_from(
14098 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
14099 ) -> Self {
14100 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
14101 }
14102 }
14103
14104 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
14105 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
14106 {
14107 #[inline]
14108 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
14109 Self {
14110 id: ::fidl_next::CompatFrom::compat_from(value.id),
14111
14112 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
14113 }
14114 }
14115 }
14116
14117 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
14118 for crate::CapabilityStoreImportRequest
14119 {
14120 #[inline]
14121 fn compat_from(
14122 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
14123 ) -> Self {
14124 Self {
14125 id: ::fidl_next::CompatFrom::compat_from(value.id),
14126
14127 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
14128 }
14129 }
14130 }
14131
14132 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
14133 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
14134 {
14135 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
14136 Self {
14137 id: ::fidl_next::CompatFrom::compat_from(value.id),
14138
14139 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14140
14141 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14142
14143 path: ::fidl_next::CompatFrom::compat_from(value.path),
14144
14145 __source_breaking: ::fidl::marker::SourceBreaking,
14146 }
14147 }
14148 }
14149
14150 impl
14151 ::fidl_next::CompatFrom<
14152 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
14153 > for crate::CapabilityStoreDirConnectorOpenRequest
14154 {
14155 fn compat_from(
14156 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
14157 ) -> Self {
14158 Self {
14159 id: ::fidl_next::CompatFrom::compat_from(value.id),
14160
14161 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14162
14163 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14164
14165 path: ::fidl_next::CompatFrom::compat_from(value.path),
14166 }
14167 }
14168 }
14169
14170 #[cfg(target_os = "fuchsia")]
14171 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
14174
14175 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
14176 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
14177 {
14178 fn compat_from(_: crate::CapabilityStore) -> Self {
14179 Self
14180 }
14181 }
14182
14183 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
14184 for crate::CapabilityStore
14185 {
14186 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
14187 Self
14188 }
14189 }
14190
14191 #[cfg(target_os = "fuchsia")]
14192
14193 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
14194 for crate::CapabilityStore
14195 {
14196 fn client_compat_from(
14197 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
14198 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14199 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14200 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14201 ::fidl_next::ClientDispatcher::new(client_end)
14202 }
14203 }
14204
14205 impl ::fidl_next::CompatFrom<crate::InstanceToken>
14206 for ::fidl_fuchsia_component_sandbox::InstanceToken
14207 {
14208 #[inline]
14209 fn compat_from(value: crate::InstanceToken) -> Self {
14210 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14211 }
14212 }
14213
14214 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
14215 for crate::InstanceToken
14216 {
14217 #[inline]
14218 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
14219 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14220 }
14221 }
14222
14223 impl ::fidl_next::CompatFrom<crate::RouteRequest>
14224 for ::fidl_fuchsia_component_sandbox::RouteRequest
14225 {
14226 fn compat_from(value: crate::RouteRequest) -> Self {
14227 Self {
14228 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
14229
14230 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
14231
14232 __source_breaking: ::fidl::marker::SourceBreaking,
14233 }
14234 }
14235 }
14236
14237 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
14238 for crate::RouteRequest
14239 {
14240 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
14241 Self {
14242 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
14243
14244 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
14245 }
14246 }
14247 }
14248
14249 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
14250 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
14251 {
14252 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
14253 match value {
14254 crate::ConnectorRouterRouteResponse::Connector(value) => {
14255 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
14256 }
14257
14258 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
14259 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14260 }
14261 }
14262 }
14263 }
14264
14265 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
14266 for crate::ConnectorRouterRouteResponse
14267 {
14268 fn compat_from(
14269 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
14270 ) -> Self {
14271 match value {
14272 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
14273 value,
14274 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
14275
14276 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
14277 value,
14278 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14279 }
14280 }
14281 }
14282
14283 #[cfg(target_os = "fuchsia")]
14284 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
14287
14288 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
14289 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
14290 {
14291 fn compat_from(_: crate::ConnectorRouter) -> Self {
14292 Self
14293 }
14294 }
14295
14296 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
14297 for crate::ConnectorRouter
14298 {
14299 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
14300 Self
14301 }
14302 }
14303
14304 #[cfg(target_os = "fuchsia")]
14305
14306 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
14307 for crate::ConnectorRouter
14308 {
14309 fn client_compat_from(
14310 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
14311 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14312 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14313 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14314 ::fidl_next::ClientDispatcher::new(client_end)
14315 }
14316 }
14317
14318 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
14319 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
14320 {
14321 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
14322 match value {
14323 crate::DataRouterRouteResponse::Data(value) => {
14324 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14325 }
14326
14327 crate::DataRouterRouteResponse::Unavailable(value) => {
14328 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14329 }
14330 }
14331 }
14332 }
14333
14334 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
14335 for crate::DataRouterRouteResponse
14336 {
14337 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
14338 match value {
14339 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
14340 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14341 }
14342
14343 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
14344 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14345 }
14346 }
14347 }
14348 }
14349
14350 #[cfg(target_os = "fuchsia")]
14351 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
14354
14355 impl ::fidl_next::CompatFrom<crate::DataRouter>
14356 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
14357 {
14358 fn compat_from(_: crate::DataRouter) -> Self {
14359 Self
14360 }
14361 }
14362
14363 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
14364 for crate::DataRouter
14365 {
14366 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
14367 Self
14368 }
14369 }
14370
14371 #[cfg(target_os = "fuchsia")]
14372
14373 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
14374 for crate::DataRouter
14375 {
14376 fn client_compat_from(
14377 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
14378 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14379 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14380 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14381 ::fidl_next::ClientDispatcher::new(client_end)
14382 }
14383 }
14384
14385 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
14386 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
14387 {
14388 #[inline]
14389 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
14390 Self {
14391 items: ::fidl_next::CompatFrom::compat_from(value.items),
14392
14393 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14394 }
14395 }
14396 }
14397
14398 impl
14399 ::fidl_next::CompatFrom<
14400 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
14401 > for crate::DictionaryDrainIteratorGetNextResponse
14402 {
14403 #[inline]
14404 fn compat_from(
14405 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
14406 ) -> Self {
14407 Self {
14408 items: ::fidl_next::CompatFrom::compat_from(value.items),
14409
14410 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14411 }
14412 }
14413 }
14414
14415 #[cfg(target_os = "fuchsia")]
14416 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
14419
14420 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
14421 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
14422 {
14423 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
14424 Self
14425 }
14426 }
14427
14428 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
14429 for crate::DictionaryDrainIterator
14430 {
14431 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
14432 Self
14433 }
14434 }
14435
14436 #[cfg(target_os = "fuchsia")]
14437
14438 impl
14439 ::fidl_next::ClientCompatFrom<
14440 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
14441 > for crate::DictionaryDrainIterator
14442 {
14443 fn client_compat_from(
14444 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
14445 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14446 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14447 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14448 ::fidl_next::ClientDispatcher::new(client_end)
14449 }
14450 }
14451
14452 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
14453 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
14454 {
14455 #[inline]
14456 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
14457 Self {
14458 key: ::fidl_next::CompatFrom::compat_from(value.key),
14459
14460 value: ::fidl_next::CompatFrom::compat_from(value.value),
14461 }
14462 }
14463 }
14464
14465 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
14466 for crate::DictionaryOptionalItem
14467 {
14468 #[inline]
14469 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
14470 Self {
14471 key: ::fidl_next::CompatFrom::compat_from(value.key),
14472
14473 value: ::fidl_next::CompatFrom::compat_from(value.value),
14474 }
14475 }
14476 }
14477
14478 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
14479 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
14480 {
14481 #[inline]
14482 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
14483 Self {
14484 items: ::fidl_next::CompatFrom::compat_from(value.items),
14485
14486 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14487 }
14488 }
14489 }
14490
14491 impl
14492 ::fidl_next::CompatFrom<
14493 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
14494 > for crate::DictionaryEnumerateIteratorGetNextResponse
14495 {
14496 #[inline]
14497 fn compat_from(
14498 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
14499 ) -> Self {
14500 Self {
14501 items: ::fidl_next::CompatFrom::compat_from(value.items),
14502
14503 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14504 }
14505 }
14506 }
14507
14508 #[cfg(target_os = "fuchsia")]
14509 pub type DictionaryEnumerateIteratorProxy =
14512 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
14513
14514 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
14515 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
14516 {
14517 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
14518 Self
14519 }
14520 }
14521
14522 impl
14523 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
14524 for crate::DictionaryEnumerateIterator
14525 {
14526 fn compat_from(
14527 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
14528 ) -> Self {
14529 Self
14530 }
14531 }
14532
14533 #[cfg(target_os = "fuchsia")]
14534
14535 impl
14536 ::fidl_next::ClientCompatFrom<
14537 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
14538 > for crate::DictionaryEnumerateIterator
14539 {
14540 fn client_compat_from(
14541 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
14542 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14543 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14544 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14545 ::fidl_next::ClientDispatcher::new(client_end)
14546 }
14547 }
14548
14549 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
14550 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
14551 {
14552 #[inline]
14553 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
14554 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
14555 }
14556 }
14557
14558 impl
14559 ::fidl_next::CompatFrom<
14560 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
14561 > for crate::DictionaryKeysIteratorGetNextResponse
14562 {
14563 #[inline]
14564 fn compat_from(
14565 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
14566 ) -> Self {
14567 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
14568 }
14569 }
14570
14571 #[cfg(target_os = "fuchsia")]
14572 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
14575
14576 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
14577 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
14578 {
14579 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
14580 Self
14581 }
14582 }
14583
14584 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
14585 for crate::DictionaryKeysIterator
14586 {
14587 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
14588 Self
14589 }
14590 }
14591
14592 #[cfg(target_os = "fuchsia")]
14593
14594 impl
14595 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
14596 for crate::DictionaryKeysIterator
14597 {
14598 fn client_compat_from(
14599 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
14600 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14601 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14602 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14603 ::fidl_next::ClientDispatcher::new(client_end)
14604 }
14605 }
14606
14607 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
14608 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
14609 {
14610 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
14611 match value {
14612 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
14613 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
14614 }
14615
14616 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
14617 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14618 }
14619 }
14620 }
14621 }
14622
14623 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
14624 for crate::DictionaryRouterRouteResponse
14625 {
14626 fn compat_from(
14627 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
14628 ) -> Self {
14629 match value {
14630 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
14631 value,
14632 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
14633
14634 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
14635 value,
14636 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14637 }
14638 }
14639 }
14640
14641 #[cfg(target_os = "fuchsia")]
14642 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
14645
14646 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
14647 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
14648 {
14649 fn compat_from(_: crate::DictionaryRouter) -> Self {
14650 Self
14651 }
14652 }
14653
14654 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
14655 for crate::DictionaryRouter
14656 {
14657 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
14658 Self
14659 }
14660 }
14661
14662 #[cfg(target_os = "fuchsia")]
14663
14664 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
14665 for crate::DictionaryRouter
14666 {
14667 fn client_compat_from(
14668 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
14669 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14670 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14671 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14672 ::fidl_next::ClientDispatcher::new(client_end)
14673 }
14674 }
14675
14676 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
14677 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
14678 {
14679 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
14680 match value {
14681 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
14682 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
14683 }
14684
14685 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
14686 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14687 }
14688 }
14689 }
14690 }
14691
14692 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
14693 for crate::DirConnectorRouterRouteResponse
14694 {
14695 fn compat_from(
14696 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
14697 ) -> Self {
14698 match value {
14699 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
14700 value,
14701 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
14702
14703 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
14704 value,
14705 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14706 }
14707 }
14708 }
14709
14710 #[cfg(target_os = "fuchsia")]
14711 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
14714
14715 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
14716 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
14717 {
14718 fn compat_from(_: crate::DirConnectorRouter) -> Self {
14719 Self
14720 }
14721 }
14722
14723 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
14724 for crate::DirConnectorRouter
14725 {
14726 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
14727 Self
14728 }
14729 }
14730
14731 #[cfg(target_os = "fuchsia")]
14732
14733 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
14734 for crate::DirConnectorRouter
14735 {
14736 fn client_compat_from(
14737 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
14738 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14739 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14740 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14741 ::fidl_next::ClientDispatcher::new(client_end)
14742 }
14743 }
14744
14745 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
14746 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
14747 {
14748 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
14749 match value {
14750 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
14751 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
14752 }
14753
14754 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
14755 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14756 }
14757 }
14758 }
14759 }
14760
14761 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
14762 for crate::DirEntryRouterRouteResponse
14763 {
14764 fn compat_from(
14765 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
14766 ) -> Self {
14767 match value {
14768 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
14769 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
14770 }
14771
14772 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
14773 value,
14774 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14775 }
14776 }
14777 }
14778
14779 #[cfg(target_os = "fuchsia")]
14780 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
14783
14784 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
14785 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
14786 {
14787 fn compat_from(_: crate::DirEntryRouter) -> Self {
14788 Self
14789 }
14790 }
14791
14792 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
14793 for crate::DirEntryRouter
14794 {
14795 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
14796 Self
14797 }
14798 }
14799
14800 #[cfg(target_os = "fuchsia")]
14801
14802 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
14803 for crate::DirEntryRouter
14804 {
14805 fn client_compat_from(
14806 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
14807 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14808 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14809 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14810 ::fidl_next::ClientDispatcher::new(client_end)
14811 }
14812 }
14813
14814 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
14815 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
14816 {
14817 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
14818 Self {
14819 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
14820
14821 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14822
14823 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
14824
14825 __source_breaking: ::fidl::marker::SourceBreaking,
14826 }
14827 }
14828 }
14829
14830 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
14831 for crate::DirReceiverReceiveRequest
14832 {
14833 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
14834 Self {
14835 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
14836
14837 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14838
14839 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
14840 }
14841 }
14842 }
14843
14844 #[cfg(target_os = "fuchsia")]
14845 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
14848
14849 impl ::fidl_next::CompatFrom<crate::DirReceiver>
14850 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
14851 {
14852 fn compat_from(_: crate::DirReceiver) -> Self {
14853 Self
14854 }
14855 }
14856
14857 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
14858 for crate::DirReceiver
14859 {
14860 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
14861 Self
14862 }
14863 }
14864
14865 #[cfg(target_os = "fuchsia")]
14866
14867 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
14868 for crate::DirReceiver
14869 {
14870 fn client_compat_from(
14871 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
14872 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14873 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14874 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14875 ::fidl_next::ClientDispatcher::new(client_end)
14876 }
14877 }
14878
14879 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
14880 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
14881 {
14882 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
14883 match value {
14884 crate::DirectoryRouterRouteResponse::Directory(value) => {
14885 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
14886 }
14887
14888 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
14889 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14890 }
14891 }
14892 }
14893 }
14894
14895 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
14896 for crate::DirectoryRouterRouteResponse
14897 {
14898 fn compat_from(
14899 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
14900 ) -> Self {
14901 match value {
14902 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
14903 value,
14904 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
14905
14906 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
14907 value,
14908 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14909 }
14910 }
14911 }
14912
14913 #[cfg(target_os = "fuchsia")]
14914 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
14917
14918 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
14919 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
14920 {
14921 fn compat_from(_: crate::DirectoryRouter) -> Self {
14922 Self
14923 }
14924 }
14925
14926 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
14927 for crate::DirectoryRouter
14928 {
14929 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
14930 Self
14931 }
14932 }
14933
14934 #[cfg(target_os = "fuchsia")]
14935
14936 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
14937 for crate::DirectoryRouter
14938 {
14939 fn client_compat_from(
14940 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
14941 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14942 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14943 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14944 ::fidl_next::ClientDispatcher::new(client_end)
14945 }
14946 }
14947
14948 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
14949 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
14950 {
14951 #[inline]
14952 fn compat_from(value: crate::ProtocolPayload) -> Self {
14953 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
14954 }
14955 }
14956
14957 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
14958 for crate::ProtocolPayload
14959 {
14960 #[inline]
14961 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
14962 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
14963 }
14964 }
14965
14966 #[cfg(target_os = "fuchsia")]
14967 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
14970
14971 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
14972 fn compat_from(_: crate::Receiver) -> Self {
14973 Self
14974 }
14975 }
14976
14977 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
14978 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
14979 Self
14980 }
14981 }
14982
14983 #[cfg(target_os = "fuchsia")]
14984
14985 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
14986 for crate::Receiver
14987 {
14988 fn client_compat_from(
14989 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
14990 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14991 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14992 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14993 ::fidl_next::ClientDispatcher::new(client_end)
14994 }
14995 }
14996}