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::wire::fuchsia::EventPair,
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::wire::Box<'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::wire::Box<'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::wire::Box::encode_present(out);
74 } else {
75 ::fidl_next::wire::Box::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::wire::fuchsia::EventPair,
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::wire::Envelope>::uninit();
145 ::fidl_next::Wire::zero_padding(&mut out);
146
147 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
148 ::fidl_next::wire::Envelope,
149 >(encoder, max_ord);
150
151 for i in 1..=max_ord {
152 match i {
153 3 => {
154 if let Some(value) = self.renamed_instances.take() {
155 ::fidl_next::wire::Envelope::encode_value::<
156 ::fidl_next::wire::Vector<
157 'static,
158 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'static>,
159 >,
160 ___E,
161 >(
162 value, preallocated.encoder, &mut out, (4294967295, ())
163 )?;
164 } else {
165 ::fidl_next::wire::Envelope::encode_zero(&mut out)
166 }
167 }
168
169 2 => {
170 if let Some(value) = self.source_instance_filter.take() {
171 ::fidl_next::wire::Envelope::encode_value::<
172 ::fidl_next::wire::Vector<
173 'static,
174 ::fidl_next::wire::String<'static>,
175 >,
176 ___E,
177 >(
178 value, preallocated.encoder, &mut out, (4294967295, 255)
179 )?;
180 } else {
181 ::fidl_next::wire::Envelope::encode_zero(&mut out)
182 }
183 }
184
185 1 => {
186 if let Some(value) = self.dir_connector.take() {
187 ::fidl_next::wire::Envelope::encode_value::<
188 crate::wire::DirConnector,
189 ___E,
190 >(
191 value, preallocated.encoder, &mut out, ()
192 )?;
193 } else {
194 ::fidl_next::wire::Envelope::encode_zero(&mut out)
195 }
196 }
197
198 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
199 }
200 unsafe {
201 preallocated.write_next(out.assume_init_ref());
202 }
203 }
204
205 ::fidl_next::wire::Table::encode_len(table, max_ord);
206
207 Ok(())
208 }
209 }
210
211 impl<'de> ::fidl_next::FromWire<crate::wire::AggregateSource<'de>> for AggregateSource {
212 #[inline]
213 fn from_wire(wire_: crate::wire::AggregateSource<'de>) -> Self {
214 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
215
216 let dir_connector = wire_.table.get(1);
217
218 let source_instance_filter = wire_.table.get(2);
219
220 let renamed_instances = wire_.table.get(3);
221
222 Self {
223
224
225 dir_connector: dir_connector.map(|envelope| ::fidl_next::FromWire::from_wire(
226 unsafe { envelope.read_unchecked::<crate::wire::DirConnector>() }
227 )),
228
229
230 source_instance_filter: source_instance_filter.map(|envelope| ::fidl_next::FromWire::from_wire(
231 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>() }
232 )),
233
234
235 renamed_instances: renamed_instances.map(|envelope| ::fidl_next::FromWire::from_wire(
236 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>>>() }
237 )),
238
239 }
240 }
241 }
242
243 #[derive(Debug, PartialEq)]
244 #[repr(C)]
245 pub struct DictionaryRef {
246 pub token: ::fidl_next::fuchsia::zx::EventPair,
247 }
248
249 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef
250 where
251 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
252 ___E: ::fidl_next::fuchsia::HandleEncoder,
253 {
254 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DictionaryRef> = unsafe {
255 ::fidl_next::CopyOptimization::enable_if(
256 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
257 ::fidl_next::wire::fuchsia::EventPair,
258 ___E,
259 >>::COPY_OPTIMIZATION
260 .is_enabled(),
261 )
262 };
263
264 #[inline]
265 fn encode(
266 self,
267 encoder_: &mut ___E,
268 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
269 _: (),
270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
271 ::fidl_next::munge! {
272 let crate::wire::DictionaryRef {
273 token,
274
275 } = out_;
276 }
277
278 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
279
280 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
281
282 Ok(())
283 }
284 }
285
286 unsafe impl<___E>
287 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DictionaryRef>, ___E>
288 for DictionaryRef
289 where
290 ___E: ::fidl_next::Encoder + ?Sized,
291 DictionaryRef: ::fidl_next::Encode<crate::wire::DictionaryRef, ___E>,
292 {
293 #[inline]
294 fn encode_option(
295 this: ::core::option::Option<Self>,
296 encoder: &mut ___E,
297 out: &mut ::core::mem::MaybeUninit<
298 ::fidl_next::wire::Box<'static, crate::wire::DictionaryRef>,
299 >,
300 _: (),
301 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
302 if let Some(inner) = this {
303 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
304 ::fidl_next::wire::Box::encode_present(out);
305 } else {
306 ::fidl_next::wire::Box::encode_absent(out);
307 }
308
309 Ok(())
310 }
311 }
312
313 impl ::fidl_next::FromWire<crate::wire::DictionaryRef> for DictionaryRef {
314 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DictionaryRef, Self> = unsafe {
315 ::fidl_next::CopyOptimization::enable_if(
316 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
317 ::fidl_next::wire::fuchsia::EventPair,
318 >>::COPY_OPTIMIZATION
319 .is_enabled(),
320 )
321 };
322
323 #[inline]
324 fn from_wire(wire: crate::wire::DictionaryRef) -> Self {
325 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
326 }
327 }
328
329 #[derive(Debug, PartialEq)]
330 #[repr(C)]
331 pub struct Connector {
332 pub token: ::fidl_next::fuchsia::zx::EventPair,
333 }
334
335 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector
336 where
337 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
338 ___E: ::fidl_next::fuchsia::HandleEncoder,
339 {
340 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Connector> = unsafe {
341 ::fidl_next::CopyOptimization::enable_if(
342 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
343 ::fidl_next::wire::fuchsia::EventPair,
344 ___E,
345 >>::COPY_OPTIMIZATION
346 .is_enabled(),
347 )
348 };
349
350 #[inline]
351 fn encode(
352 self,
353 encoder_: &mut ___E,
354 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
355 _: (),
356 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
357 ::fidl_next::munge! {
358 let crate::wire::Connector {
359 token,
360
361 } = out_;
362 }
363
364 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
365
366 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
367
368 Ok(())
369 }
370 }
371
372 unsafe impl<___E>
373 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::Connector>, ___E>
374 for Connector
375 where
376 ___E: ::fidl_next::Encoder + ?Sized,
377 Connector: ::fidl_next::Encode<crate::wire::Connector, ___E>,
378 {
379 #[inline]
380 fn encode_option(
381 this: ::core::option::Option<Self>,
382 encoder: &mut ___E,
383 out: &mut ::core::mem::MaybeUninit<
384 ::fidl_next::wire::Box<'static, crate::wire::Connector>,
385 >,
386 _: (),
387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
388 if let Some(inner) = this {
389 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
390 ::fidl_next::wire::Box::encode_present(out);
391 } else {
392 ::fidl_next::wire::Box::encode_absent(out);
393 }
394
395 Ok(())
396 }
397 }
398
399 impl ::fidl_next::FromWire<crate::wire::Connector> for Connector {
400 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Connector, Self> = unsafe {
401 ::fidl_next::CopyOptimization::enable_if(
402 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
403 ::fidl_next::wire::fuchsia::EventPair,
404 >>::COPY_OPTIMIZATION
405 .is_enabled(),
406 )
407 };
408
409 #[inline]
410 fn from_wire(wire: crate::wire::Connector) -> Self {
411 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
412 }
413 }
414
415 #[derive(Debug, PartialEq)]
416 #[repr(C)]
417 pub struct DirEntry {
418 pub token: ::fidl_next::fuchsia::zx::EventPair,
419 }
420
421 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry
422 where
423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
424 ___E: ::fidl_next::fuchsia::HandleEncoder,
425 {
426 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirEntry> = unsafe {
427 ::fidl_next::CopyOptimization::enable_if(
428 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
429 ::fidl_next::wire::fuchsia::EventPair,
430 ___E,
431 >>::COPY_OPTIMIZATION
432 .is_enabled(),
433 )
434 };
435
436 #[inline]
437 fn encode(
438 self,
439 encoder_: &mut ___E,
440 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
441 _: (),
442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
443 ::fidl_next::munge! {
444 let crate::wire::DirEntry {
445 token,
446
447 } = out_;
448 }
449
450 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
451
452 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
453
454 Ok(())
455 }
456 }
457
458 unsafe impl<___E>
459 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::DirEntry>, ___E>
460 for DirEntry
461 where
462 ___E: ::fidl_next::Encoder + ?Sized,
463 DirEntry: ::fidl_next::Encode<crate::wire::DirEntry, ___E>,
464 {
465 #[inline]
466 fn encode_option(
467 this: ::core::option::Option<Self>,
468 encoder: &mut ___E,
469 out: &mut ::core::mem::MaybeUninit<
470 ::fidl_next::wire::Box<'static, crate::wire::DirEntry>,
471 >,
472 _: (),
473 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
474 if let Some(inner) = this {
475 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
476 ::fidl_next::wire::Box::encode_present(out);
477 } else {
478 ::fidl_next::wire::Box::encode_absent(out);
479 }
480
481 Ok(())
482 }
483 }
484
485 impl ::fidl_next::FromWire<crate::wire::DirEntry> for DirEntry {
486 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirEntry, Self> = unsafe {
487 ::fidl_next::CopyOptimization::enable_if(
488 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
489 ::fidl_next::wire::fuchsia::EventPair,
490 >>::COPY_OPTIMIZATION
491 .is_enabled(),
492 )
493 };
494
495 #[inline]
496 fn from_wire(wire: crate::wire::DirEntry) -> Self {
497 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
498 }
499 }
500
501 #[derive(Debug, PartialEq)]
502 pub enum Capability {
503 Unit(crate::natural::Unit),
504
505 Handle(::fidl_next::fuchsia::zx::NullableHandle),
506
507 Data(crate::natural::Data),
508
509 Dictionary(crate::natural::DictionaryRef),
510
511 Connector(crate::natural::Connector),
512
513 DirConnector(crate::natural::DirConnector),
514
515 Directory(
516 ::fidl_next::ClientEnd<
517 ::fidl_next_fuchsia_io::Directory,
518 ::fidl_next::fuchsia::zx::Channel,
519 >,
520 ),
521
522 DirEntry(crate::natural::DirEntry),
523
524 ConnectorRouter(
525 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
526 ),
527
528 DictionaryRouter(
529 ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
530 ),
531
532 DirEntryRouter(
533 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
534 ),
535
536 DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
537
538 DirConnectorRouter(
539 ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
540 ),
541
542 UnknownOrdinal_(u64),
543 }
544
545 impl Capability {
546 pub fn is_unknown(&self) -> bool {
547 #[allow(unreachable_patterns)]
548 match self {
549 Self::UnknownOrdinal_(_) => true,
550 _ => false,
551 }
552 }
553 }
554
555 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Capability<'static>, ___E> for Capability
556 where
557 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
558 ___E: ::fidl_next::Encoder,
559 ___E: ::fidl_next::fuchsia::HandleEncoder,
560 {
561 #[inline]
562 fn encode(
563 self,
564 encoder: &mut ___E,
565 out: &mut ::core::mem::MaybeUninit<crate::wire::Capability<'static>>,
566 _: (),
567 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
568 ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);
569
570 match self {
571 Self::Unit(value) => {
572 ::fidl_next::wire::Union::encode_as::<___E, crate::wire::Unit>(
573 value,
574 1,
575 encoder,
576 raw,
577 (),
578 )?
579 }
580
581 Self::Handle(value) => ::fidl_next::wire::Union::encode_as::<
582 ___E,
583 ::fidl_next::wire::fuchsia::NullableHandle,
584 >(value, 2, encoder, raw, ())?,
585
586 Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
587 ___E,
588 crate::wire::Data<'static>,
589 >(value, 3, encoder, raw, ())?,
590
591 Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as::<
592 ___E,
593 crate::wire::DictionaryRef,
594 >(value, 4, encoder, raw, ())?,
595
596 Self::Connector(value) => ::fidl_next::wire::Union::encode_as::<
597 ___E,
598 crate::wire::Connector,
599 >(value, 5, encoder, raw, ())?,
600
601 Self::DirConnector(value) => ::fidl_next::wire::Union::encode_as::<
602 ___E,
603 crate::wire::DirConnector,
604 >(value, 6, encoder, raw, ())?,
605
606 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
607 ___E,
608 ::fidl_next::ClientEnd<
609 ::fidl_next_fuchsia_io::Directory,
610 ::fidl_next::wire::fuchsia::Channel,
611 >,
612 >(value, 7, encoder, raw, ())?,
613
614 Self::DirEntry(value) => ::fidl_next::wire::Union::encode_as::<
615 ___E,
616 crate::wire::DirEntry,
617 >(value, 8, encoder, raw, ())?,
618
619 Self::ConnectorRouter(value) => ::fidl_next::wire::Union::encode_as::<
620 ___E,
621 ::fidl_next::ClientEnd<
622 crate::ConnectorRouter,
623 ::fidl_next::wire::fuchsia::Channel,
624 >,
625 >(value, 9, encoder, raw, ())?,
626
627 Self::DictionaryRouter(value) => ::fidl_next::wire::Union::encode_as::<
628 ___E,
629 ::fidl_next::ClientEnd<
630 crate::DictionaryRouter,
631 ::fidl_next::wire::fuchsia::Channel,
632 >,
633 >(value, 10, encoder, raw, ())?,
634
635 Self::DirEntryRouter(value) => ::fidl_next::wire::Union::encode_as::<
636 ___E,
637 ::fidl_next::ClientEnd<
638 crate::DirEntryRouter,
639 ::fidl_next::wire::fuchsia::Channel,
640 >,
641 >(value, 11, encoder, raw, ())?,
642
643 Self::DataRouter(value) => ::fidl_next::wire::Union::encode_as::<
644 ___E,
645 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
646 >(value, 12, encoder, raw, ())?,
647
648 Self::DirConnectorRouter(value) => ::fidl_next::wire::Union::encode_as::<
649 ___E,
650 ::fidl_next::ClientEnd<
651 crate::DirConnectorRouter,
652 ::fidl_next::wire::fuchsia::Channel,
653 >,
654 >(value, 13, encoder, raw, ())?,
655
656 Self::UnknownOrdinal_(ordinal) => {
657 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
658 }
659 }
660
661 Ok(())
662 }
663 }
664
665 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Capability<'static>, ___E>
666 for Capability
667 where
668 ___E: ?Sized,
669 Capability: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
670 {
671 #[inline]
672 fn encode_option(
673 this: ::core::option::Option<Self>,
674 encoder: &mut ___E,
675 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Capability<'static>>,
676 _: (),
677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
678 ::fidl_next::munge!(let crate::wire_optional::Capability { raw, _phantom: _ } = &mut *out);
679
680 if let Some(inner) = this {
681 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
682 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
683 } else {
684 ::fidl_next::wire::Union::encode_absent(raw);
685 }
686
687 Ok(())
688 }
689 }
690
691 impl<'de> ::fidl_next::FromWire<crate::wire::Capability<'de>> for Capability {
692 #[inline]
693 fn from_wire(wire: crate::wire::Capability<'de>) -> Self {
694 let wire = ::core::mem::ManuallyDrop::new(wire);
695 match wire.raw.ordinal() {
696 1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
697 wire.raw.get().read_unchecked::<crate::wire::Unit>()
698 })),
699
700 2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
701 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
702 })),
703
704 3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
705 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
706 })),
707
708 4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
709 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
710 })),
711
712 5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
713 wire.raw.get().read_unchecked::<crate::wire::Connector>()
714 })),
715
716 6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
717 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
718 })),
719
720 7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
721 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
722 ::fidl_next_fuchsia_io::Directory,
723 ::fidl_next::wire::fuchsia::Channel,
724 >>()
725 })),
726
727 8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
728 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
729 })),
730
731 9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
732 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
733 crate::ConnectorRouter,
734 ::fidl_next::wire::fuchsia::Channel,
735 >>()
736 })),
737
738 10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
739 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
740 crate::DictionaryRouter,
741 ::fidl_next::wire::fuchsia::Channel,
742 >>()
743 })),
744
745 11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
746 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
747 crate::DirEntryRouter,
748 ::fidl_next::wire::fuchsia::Channel,
749 >>()
750 })),
751
752 12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
753 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
754 crate::DataRouter,
755 ::fidl_next::wire::fuchsia::Channel,
756 >>()
757 })),
758
759 13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
760 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
761 crate::DirConnectorRouter,
762 ::fidl_next::wire::fuchsia::Channel,
763 >>()
764 })),
765
766 ord => return Self::UnknownOrdinal_(ord as u64),
767 }
768 }
769 }
770
771 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Capability {
772 #[inline]
773 fn from_wire_option(
774 wire: crate::wire_optional::Capability<'de>,
775 ) -> ::core::option::Option<Self> {
776 if let Some(inner) = wire.into_option() {
777 Some(::fidl_next::FromWire::from_wire(inner))
778 } else {
779 None
780 }
781 }
782 }
783
784 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
785 #[inline]
786 fn from_wire_option(
787 wire: crate::wire_optional::Capability<'de>,
788 ) -> ::core::option::Option<Self> {
789 <
790 Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
791 >::from_wire_option(wire).map(Box::new)
792 }
793 }
794
795 #[derive(Debug, PartialEq)]
796 pub struct CapabilityStoreConnectorCreateRequest {
797 pub id: u64,
798
799 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
800 }
801
802 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
803 for CapabilityStoreConnectorCreateRequest
804 where
805 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
806 ___E: ::fidl_next::fuchsia::HandleEncoder,
807 {
808 #[inline]
809 fn encode(
810 self,
811 encoder_: &mut ___E,
812 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
813 _: (),
814 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
815 ::fidl_next::munge! {
816 let crate::wire::CapabilityStoreConnectorCreateRequest {
817 id,
818 receiver,
819
820 } = out_;
821 }
822
823 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
824
825 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
826
827 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
828
829 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
830
831 Ok(())
832 }
833 }
834
835 unsafe impl<___E>
836 ::fidl_next::EncodeOption<
837 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
838 ___E,
839 > for CapabilityStoreConnectorCreateRequest
840 where
841 ___E: ::fidl_next::Encoder + ?Sized,
842 CapabilityStoreConnectorCreateRequest:
843 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>,
844 {
845 #[inline]
846 fn encode_option(
847 this: ::core::option::Option<Self>,
848 encoder: &mut ___E,
849 out: &mut ::core::mem::MaybeUninit<
850 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorCreateRequest>,
851 >,
852 _: (),
853 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
854 if let Some(inner) = this {
855 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
856 ::fidl_next::wire::Box::encode_present(out);
857 } else {
858 ::fidl_next::wire::Box::encode_absent(out);
859 }
860
861 Ok(())
862 }
863 }
864
865 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateRequest>
866 for CapabilityStoreConnectorCreateRequest
867 {
868 #[inline]
869 fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateRequest) -> Self {
870 Self {
871 id: ::fidl_next::FromWire::from_wire(wire.id),
872
873 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
874 }
875 }
876 }
877
878 #[derive(Debug, PartialEq)]
879 pub struct CapabilityStoreConnectorOpenRequest {
880 pub id: u64,
881
882 pub server_end: ::fidl_next::fuchsia::zx::Channel,
883 }
884
885 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
886 for CapabilityStoreConnectorOpenRequest
887 where
888 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
889 ___E: ::fidl_next::fuchsia::HandleEncoder,
890 {
891 #[inline]
892 fn encode(
893 self,
894 encoder_: &mut ___E,
895 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
896 _: (),
897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
898 ::fidl_next::munge! {
899 let crate::wire::CapabilityStoreConnectorOpenRequest {
900 id,
901 server_end,
902
903 } = out_;
904 }
905
906 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
907
908 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
909
910 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
911
912 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
913
914 Ok(())
915 }
916 }
917
918 unsafe impl<___E>
919 ::fidl_next::EncodeOption<
920 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
921 ___E,
922 > for CapabilityStoreConnectorOpenRequest
923 where
924 ___E: ::fidl_next::Encoder + ?Sized,
925 CapabilityStoreConnectorOpenRequest:
926 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>,
927 {
928 #[inline]
929 fn encode_option(
930 this: ::core::option::Option<Self>,
931 encoder: &mut ___E,
932 out: &mut ::core::mem::MaybeUninit<
933 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreConnectorOpenRequest>,
934 >,
935 _: (),
936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
937 if let Some(inner) = this {
938 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
939 ::fidl_next::wire::Box::encode_present(out);
940 } else {
941 ::fidl_next::wire::Box::encode_absent(out);
942 }
943
944 Ok(())
945 }
946 }
947
948 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenRequest>
949 for CapabilityStoreConnectorOpenRequest
950 {
951 #[inline]
952 fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenRequest) -> Self {
953 Self {
954 id: ::fidl_next::FromWire::from_wire(wire.id),
955
956 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
957 }
958 }
959 }
960
961 #[derive(Debug, PartialEq)]
962 pub struct CapabilityStoreDirConnectorCreateRequest {
963 pub id: u64,
964
965 pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
966 }
967
968 unsafe impl<___E>
969 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
970 for CapabilityStoreDirConnectorCreateRequest
971 where
972 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
973 ___E: ::fidl_next::fuchsia::HandleEncoder,
974 {
975 #[inline]
976 fn encode(
977 self,
978 encoder_: &mut ___E,
979 out_: &mut ::core::mem::MaybeUninit<
980 crate::wire::CapabilityStoreDirConnectorCreateRequest,
981 >,
982 _: (),
983 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
984 ::fidl_next::munge! {
985 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
986 id,
987 receiver,
988
989 } = out_;
990 }
991
992 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
993
994 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
995
996 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
997
998 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
999
1000 Ok(())
1001 }
1002 }
1003
1004 unsafe impl<___E>
1005 ::fidl_next::EncodeOption<
1006 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>,
1007 ___E,
1008 > for CapabilityStoreDirConnectorCreateRequest
1009 where
1010 ___E: ::fidl_next::Encoder + ?Sized,
1011 CapabilityStoreDirConnectorCreateRequest:
1012 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>,
1013 {
1014 #[inline]
1015 fn encode_option(
1016 this: ::core::option::Option<Self>,
1017 encoder: &mut ___E,
1018 out: &mut ::core::mem::MaybeUninit<
1019 ::fidl_next::wire::Box<
1020 'static,
1021 crate::wire::CapabilityStoreDirConnectorCreateRequest,
1022 >,
1023 >,
1024 _: (),
1025 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1026 if let Some(inner) = this {
1027 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1028 ::fidl_next::wire::Box::encode_present(out);
1029 } else {
1030 ::fidl_next::wire::Box::encode_absent(out);
1031 }
1032
1033 Ok(())
1034 }
1035 }
1036
1037 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
1038 for CapabilityStoreDirConnectorCreateRequest
1039 {
1040 #[inline]
1041 fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
1042 Self {
1043 id: ::fidl_next::FromWire::from_wire(wire.id),
1044
1045 receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
1046 }
1047 }
1048 }
1049
1050 #[derive(Debug, PartialEq)]
1051 pub struct CapabilityStoreDictionaryLegacyImportRequest {
1052 pub id: u64,
1053
1054 pub client_end: ::fidl_next::fuchsia::zx::Channel,
1055 }
1056
1057 unsafe impl<___E>
1058 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
1059 for CapabilityStoreDictionaryLegacyImportRequest
1060 where
1061 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1062 ___E: ::fidl_next::fuchsia::HandleEncoder,
1063 {
1064 #[inline]
1065 fn encode(
1066 self,
1067 encoder_: &mut ___E,
1068 out_: &mut ::core::mem::MaybeUninit<
1069 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1070 >,
1071 _: (),
1072 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1073 ::fidl_next::munge! {
1074 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
1075 id,
1076 client_end,
1077
1078 } = out_;
1079 }
1080
1081 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1082
1083 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1084
1085 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
1086
1087 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
1088
1089 Ok(())
1090 }
1091 }
1092
1093 unsafe impl<___E>
1094 ::fidl_next::EncodeOption<
1095 ::fidl_next::wire::Box<
1096 'static,
1097 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1098 >,
1099 ___E,
1100 > for CapabilityStoreDictionaryLegacyImportRequest
1101 where
1102 ___E: ::fidl_next::Encoder + ?Sized,
1103 CapabilityStoreDictionaryLegacyImportRequest:
1104 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>,
1105 {
1106 #[inline]
1107 fn encode_option(
1108 this: ::core::option::Option<Self>,
1109 encoder: &mut ___E,
1110 out: &mut ::core::mem::MaybeUninit<
1111 ::fidl_next::wire::Box<
1112 'static,
1113 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
1114 >,
1115 >,
1116 _: (),
1117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1118 if let Some(inner) = this {
1119 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1120 ::fidl_next::wire::Box::encode_present(out);
1121 } else {
1122 ::fidl_next::wire::Box::encode_absent(out);
1123 }
1124
1125 Ok(())
1126 }
1127 }
1128
1129 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
1130 for CapabilityStoreDictionaryLegacyImportRequest
1131 {
1132 #[inline]
1133 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
1134 Self {
1135 id: ::fidl_next::FromWire::from_wire(wire.id),
1136
1137 client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
1138 }
1139 }
1140 }
1141
1142 #[derive(Debug, PartialEq)]
1143 pub struct CapabilityStoreDictionaryLegacyExportRequest {
1144 pub id: u64,
1145
1146 pub server_end: ::fidl_next::fuchsia::zx::Channel,
1147 }
1148
1149 unsafe impl<___E>
1150 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
1151 for CapabilityStoreDictionaryLegacyExportRequest
1152 where
1153 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1154 ___E: ::fidl_next::fuchsia::HandleEncoder,
1155 {
1156 #[inline]
1157 fn encode(
1158 self,
1159 encoder_: &mut ___E,
1160 out_: &mut ::core::mem::MaybeUninit<
1161 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1162 >,
1163 _: (),
1164 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1165 ::fidl_next::munge! {
1166 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
1167 id,
1168 server_end,
1169
1170 } = out_;
1171 }
1172
1173 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1174
1175 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1176
1177 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
1178
1179 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
1180
1181 Ok(())
1182 }
1183 }
1184
1185 unsafe impl<___E>
1186 ::fidl_next::EncodeOption<
1187 ::fidl_next::wire::Box<
1188 'static,
1189 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1190 >,
1191 ___E,
1192 > for CapabilityStoreDictionaryLegacyExportRequest
1193 where
1194 ___E: ::fidl_next::Encoder + ?Sized,
1195 CapabilityStoreDictionaryLegacyExportRequest:
1196 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>,
1197 {
1198 #[inline]
1199 fn encode_option(
1200 this: ::core::option::Option<Self>,
1201 encoder: &mut ___E,
1202 out: &mut ::core::mem::MaybeUninit<
1203 ::fidl_next::wire::Box<
1204 'static,
1205 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
1206 >,
1207 >,
1208 _: (),
1209 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1210 if let Some(inner) = this {
1211 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1212 ::fidl_next::wire::Box::encode_present(out);
1213 } else {
1214 ::fidl_next::wire::Box::encode_absent(out);
1215 }
1216
1217 Ok(())
1218 }
1219 }
1220
1221 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
1222 for CapabilityStoreDictionaryLegacyExportRequest
1223 {
1224 #[inline]
1225 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
1226 Self {
1227 id: ::fidl_next::FromWire::from_wire(wire.id),
1228
1229 server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
1230 }
1231 }
1232 }
1233
1234 #[derive(Debug, PartialEq)]
1235 pub struct CapabilityStoreDictionaryKeysRequest {
1236 pub id: u64,
1237
1238 pub iterator: ::fidl_next::ServerEnd<
1239 crate::DictionaryKeysIterator,
1240 ::fidl_next::fuchsia::zx::Channel,
1241 >,
1242 }
1243
1244 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
1245 for CapabilityStoreDictionaryKeysRequest
1246 where
1247 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1248 ___E: ::fidl_next::fuchsia::HandleEncoder,
1249 {
1250 #[inline]
1251 fn encode(
1252 self,
1253 encoder_: &mut ___E,
1254 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
1255 _: (),
1256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1257 ::fidl_next::munge! {
1258 let crate::wire::CapabilityStoreDictionaryKeysRequest {
1259 id,
1260 iterator,
1261
1262 } = out_;
1263 }
1264
1265 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1266
1267 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1268
1269 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1270
1271 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1272
1273 Ok(())
1274 }
1275 }
1276
1277 unsafe impl<___E>
1278 ::fidl_next::EncodeOption<
1279 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1280 ___E,
1281 > for CapabilityStoreDictionaryKeysRequest
1282 where
1283 ___E: ::fidl_next::Encoder + ?Sized,
1284 CapabilityStoreDictionaryKeysRequest:
1285 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>,
1286 {
1287 #[inline]
1288 fn encode_option(
1289 this: ::core::option::Option<Self>,
1290 encoder: &mut ___E,
1291 out: &mut ::core::mem::MaybeUninit<
1292 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>,
1293 >,
1294 _: (),
1295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1296 if let Some(inner) = this {
1297 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1298 ::fidl_next::wire::Box::encode_present(out);
1299 } else {
1300 ::fidl_next::wire::Box::encode_absent(out);
1301 }
1302
1303 Ok(())
1304 }
1305 }
1306
1307 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
1308 for CapabilityStoreDictionaryKeysRequest
1309 {
1310 #[inline]
1311 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
1312 Self {
1313 id: ::fidl_next::FromWire::from_wire(wire.id),
1314
1315 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1316 }
1317 }
1318 }
1319
1320 #[derive(Debug, PartialEq)]
1321 pub struct CapabilityStoreDictionaryEnumerateRequest {
1322 pub id: u64,
1323
1324 pub iterator: ::fidl_next::ServerEnd<
1325 crate::DictionaryEnumerateIterator,
1326 ::fidl_next::fuchsia::zx::Channel,
1327 >,
1328 }
1329
1330 unsafe impl<___E>
1331 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
1332 for CapabilityStoreDictionaryEnumerateRequest
1333 where
1334 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1335 ___E: ::fidl_next::fuchsia::HandleEncoder,
1336 {
1337 #[inline]
1338 fn encode(
1339 self,
1340 encoder_: &mut ___E,
1341 out_: &mut ::core::mem::MaybeUninit<
1342 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1343 >,
1344 _: (),
1345 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1346 ::fidl_next::munge! {
1347 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
1348 id,
1349 iterator,
1350
1351 } = out_;
1352 }
1353
1354 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1355
1356 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1357
1358 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1359
1360 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1361
1362 Ok(())
1363 }
1364 }
1365
1366 unsafe impl<___E>
1367 ::fidl_next::EncodeOption<
1368 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>,
1369 ___E,
1370 > for CapabilityStoreDictionaryEnumerateRequest
1371 where
1372 ___E: ::fidl_next::Encoder + ?Sized,
1373 CapabilityStoreDictionaryEnumerateRequest:
1374 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>,
1375 {
1376 #[inline]
1377 fn encode_option(
1378 this: ::core::option::Option<Self>,
1379 encoder: &mut ___E,
1380 out: &mut ::core::mem::MaybeUninit<
1381 ::fidl_next::wire::Box<
1382 'static,
1383 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
1384 >,
1385 >,
1386 _: (),
1387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1388 if let Some(inner) = this {
1389 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1390 ::fidl_next::wire::Box::encode_present(out);
1391 } else {
1392 ::fidl_next::wire::Box::encode_absent(out);
1393 }
1394
1395 Ok(())
1396 }
1397 }
1398
1399 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
1400 for CapabilityStoreDictionaryEnumerateRequest
1401 {
1402 #[inline]
1403 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
1404 Self {
1405 id: ::fidl_next::FromWire::from_wire(wire.id),
1406
1407 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1408 }
1409 }
1410 }
1411
1412 #[derive(Debug, PartialEq)]
1413 pub struct CapabilityStoreDictionaryDrainRequest {
1414 pub id: u64,
1415
1416 pub iterator: ::core::option::Option<
1417 ::fidl_next::ServerEnd<
1418 crate::DictionaryDrainIterator,
1419 ::fidl_next::fuchsia::zx::Channel,
1420 >,
1421 >,
1422 }
1423
1424 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
1425 for CapabilityStoreDictionaryDrainRequest
1426 where
1427 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1428 ___E: ::fidl_next::fuchsia::HandleEncoder,
1429 {
1430 #[inline]
1431 fn encode(
1432 self,
1433 encoder_: &mut ___E,
1434 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
1435 _: (),
1436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1437 ::fidl_next::munge! {
1438 let crate::wire::CapabilityStoreDictionaryDrainRequest {
1439 id,
1440 iterator,
1441
1442 } = out_;
1443 }
1444
1445 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1446
1447 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1448
1449 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
1450
1451 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
1452
1453 Ok(())
1454 }
1455 }
1456
1457 unsafe impl<___E>
1458 ::fidl_next::EncodeOption<
1459 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1460 ___E,
1461 > for CapabilityStoreDictionaryDrainRequest
1462 where
1463 ___E: ::fidl_next::Encoder + ?Sized,
1464 CapabilityStoreDictionaryDrainRequest:
1465 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>,
1466 {
1467 #[inline]
1468 fn encode_option(
1469 this: ::core::option::Option<Self>,
1470 encoder: &mut ___E,
1471 out: &mut ::core::mem::MaybeUninit<
1472 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>,
1473 >,
1474 _: (),
1475 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1476 if let Some(inner) = this {
1477 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1478 ::fidl_next::wire::Box::encode_present(out);
1479 } else {
1480 ::fidl_next::wire::Box::encode_absent(out);
1481 }
1482
1483 Ok(())
1484 }
1485 }
1486
1487 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
1488 for CapabilityStoreDictionaryDrainRequest
1489 {
1490 #[inline]
1491 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
1492 Self {
1493 id: ::fidl_next::FromWire::from_wire(wire.id),
1494
1495 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
1496 }
1497 }
1498 }
1499
1500 #[derive(Debug, PartialEq)]
1501 pub struct CapabilityStoreCreateServiceAggregateRequest {
1502 pub sources: ::std::vec::Vec<crate::natural::AggregateSource>,
1503 }
1504
1505 unsafe impl<___E>
1506 ::fidl_next::Encode<
1507 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1508 ___E,
1509 > for CapabilityStoreCreateServiceAggregateRequest
1510 where
1511 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1512 ___E: ::fidl_next::Encoder,
1513 ___E: ::fidl_next::fuchsia::HandleEncoder,
1514 {
1515 #[inline]
1516 fn encode(
1517 self,
1518 encoder_: &mut ___E,
1519 out_: &mut ::core::mem::MaybeUninit<
1520 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1521 >,
1522 _: (),
1523 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1524 ::fidl_next::munge! {
1525 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
1526 sources,
1527
1528 } = out_;
1529 }
1530
1531 ::fidl_next::Encode::encode(self.sources, encoder_, sources, (4294967295, ()))?;
1532
1533 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(sources.as_mut_ptr()) };
1534 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1535
1536 Ok(())
1537 }
1538 }
1539
1540 unsafe impl<___E>
1541 ::fidl_next::EncodeOption<
1542 ::fidl_next::wire::Box<
1543 'static,
1544 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1545 >,
1546 ___E,
1547 > for CapabilityStoreCreateServiceAggregateRequest
1548 where
1549 ___E: ::fidl_next::Encoder + ?Sized,
1550 CapabilityStoreCreateServiceAggregateRequest: ::fidl_next::Encode<
1551 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1552 ___E,
1553 >,
1554 {
1555 #[inline]
1556 fn encode_option(
1557 this: ::core::option::Option<Self>,
1558 encoder: &mut ___E,
1559 out: &mut ::core::mem::MaybeUninit<
1560 ::fidl_next::wire::Box<
1561 'static,
1562 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
1563 >,
1564 >,
1565 _: (),
1566 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1567 if let Some(inner) = this {
1568 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1569 ::fidl_next::wire::Box::encode_present(out);
1570 } else {
1571 ::fidl_next::wire::Box::encode_absent(out);
1572 }
1573
1574 Ok(())
1575 }
1576 }
1577
1578 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>>
1579 for CapabilityStoreCreateServiceAggregateRequest
1580 {
1581 #[inline]
1582 fn from_wire(wire: crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>) -> Self {
1583 Self { sources: ::fidl_next::FromWire::from_wire(wire.sources) }
1584 }
1585 }
1586
1587 #[derive(Debug, PartialEq)]
1588 #[repr(C)]
1589 pub struct CapabilityStoreCreateServiceAggregateResponse {
1590 pub aggregate_dir_connector: crate::natural::DirConnector,
1591 }
1592
1593 unsafe impl<___E>
1594 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
1595 for CapabilityStoreCreateServiceAggregateResponse
1596 where
1597 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1598 ___E: ::fidl_next::fuchsia::HandleEncoder,
1599 {
1600 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1601 Self,
1602 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1603 > = unsafe {
1604 ::fidl_next::CopyOptimization::enable_if(
1605 true && <crate::natural::DirConnector as ::fidl_next::Encode<
1606 crate::wire::DirConnector,
1607 ___E,
1608 >>::COPY_OPTIMIZATION
1609 .is_enabled(),
1610 )
1611 };
1612
1613 #[inline]
1614 fn encode(
1615 self,
1616 encoder_: &mut ___E,
1617 out_: &mut ::core::mem::MaybeUninit<
1618 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1619 >,
1620 _: (),
1621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1622 ::fidl_next::munge! {
1623 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
1624 aggregate_dir_connector,
1625
1626 } = out_;
1627 }
1628
1629 ::fidl_next::Encode::encode(
1630 self.aggregate_dir_connector,
1631 encoder_,
1632 aggregate_dir_connector,
1633 (),
1634 )?;
1635
1636 let mut _field =
1637 unsafe { ::fidl_next::Slot::new_unchecked(aggregate_dir_connector.as_mut_ptr()) };
1638
1639 Ok(())
1640 }
1641 }
1642
1643 unsafe impl<___E>
1644 ::fidl_next::EncodeOption<
1645 ::fidl_next::wire::Box<
1646 'static,
1647 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1648 >,
1649 ___E,
1650 > for CapabilityStoreCreateServiceAggregateResponse
1651 where
1652 ___E: ::fidl_next::Encoder + ?Sized,
1653 CapabilityStoreCreateServiceAggregateResponse:
1654 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>,
1655 {
1656 #[inline]
1657 fn encode_option(
1658 this: ::core::option::Option<Self>,
1659 encoder: &mut ___E,
1660 out: &mut ::core::mem::MaybeUninit<
1661 ::fidl_next::wire::Box<
1662 'static,
1663 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1664 >,
1665 >,
1666 _: (),
1667 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1668 if let Some(inner) = this {
1669 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1670 ::fidl_next::wire::Box::encode_present(out);
1671 } else {
1672 ::fidl_next::wire::Box::encode_absent(out);
1673 }
1674
1675 Ok(())
1676 }
1677 }
1678
1679 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreCreateServiceAggregateResponse>
1680 for CapabilityStoreCreateServiceAggregateResponse
1681 {
1682 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1683 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
1684 Self,
1685 > = unsafe {
1686 ::fidl_next::CopyOptimization::enable_if(
1687 true && <crate::natural::DirConnector as ::fidl_next::FromWire<
1688 crate::wire::DirConnector,
1689 >>::COPY_OPTIMIZATION
1690 .is_enabled(),
1691 )
1692 };
1693
1694 #[inline]
1695 fn from_wire(wire: crate::wire::CapabilityStoreCreateServiceAggregateResponse) -> Self {
1696 Self {
1697 aggregate_dir_connector: ::fidl_next::FromWire::from_wire(
1698 wire.aggregate_dir_connector,
1699 ),
1700 }
1701 }
1702 }
1703
1704 #[derive(Debug, PartialEq)]
1705 pub struct CapabilityStoreExportResponse {
1706 pub capability: crate::natural::Capability,
1707 }
1708
1709 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
1710 for CapabilityStoreExportResponse
1711 where
1712 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1713 ___E: ::fidl_next::Encoder,
1714 ___E: ::fidl_next::fuchsia::HandleEncoder,
1715 {
1716 #[inline]
1717 fn encode(
1718 self,
1719 encoder_: &mut ___E,
1720 out_: &mut ::core::mem::MaybeUninit<
1721 crate::wire::CapabilityStoreExportResponse<'static>,
1722 >,
1723 _: (),
1724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1725 ::fidl_next::munge! {
1726 let crate::wire::CapabilityStoreExportResponse {
1727 capability,
1728
1729 } = out_;
1730 }
1731
1732 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1733
1734 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1735
1736 Ok(())
1737 }
1738 }
1739
1740 unsafe impl<___E>
1741 ::fidl_next::EncodeOption<
1742 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportResponse<'static>>,
1743 ___E,
1744 > for CapabilityStoreExportResponse
1745 where
1746 ___E: ::fidl_next::Encoder + ?Sized,
1747 CapabilityStoreExportResponse:
1748 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>,
1749 {
1750 #[inline]
1751 fn encode_option(
1752 this: ::core::option::Option<Self>,
1753 encoder: &mut ___E,
1754 out: &mut ::core::mem::MaybeUninit<
1755 ::fidl_next::wire::Box<
1756 'static,
1757 crate::wire::CapabilityStoreExportResponse<'static>,
1758 >,
1759 >,
1760 _: (),
1761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1762 if let Some(inner) = this {
1763 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1764 ::fidl_next::wire::Box::encode_present(out);
1765 } else {
1766 ::fidl_next::wire::Box::encode_absent(out);
1767 }
1768
1769 Ok(())
1770 }
1771 }
1772
1773 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
1774 for CapabilityStoreExportResponse
1775 {
1776 #[inline]
1777 fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
1778 Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
1779 }
1780 }
1781
1782 #[derive(Debug, PartialEq)]
1783 pub struct CapabilityStoreImportRequest {
1784 pub id: u64,
1785
1786 pub capability: crate::natural::Capability,
1787 }
1788
1789 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
1790 for CapabilityStoreImportRequest
1791 where
1792 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1793 ___E: ::fidl_next::Encoder,
1794 ___E: ::fidl_next::fuchsia::HandleEncoder,
1795 {
1796 #[inline]
1797 fn encode(
1798 self,
1799 encoder_: &mut ___E,
1800 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
1801 _: (),
1802 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1803 ::fidl_next::munge! {
1804 let crate::wire::CapabilityStoreImportRequest {
1805 id,
1806 capability,
1807
1808 } = out_;
1809 }
1810
1811 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1812
1813 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1814
1815 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1816
1817 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1818
1819 Ok(())
1820 }
1821 }
1822
1823 unsafe impl<___E>
1824 ::fidl_next::EncodeOption<
1825 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1826 ___E,
1827 > for CapabilityStoreImportRequest
1828 where
1829 ___E: ::fidl_next::Encoder + ?Sized,
1830 CapabilityStoreImportRequest:
1831 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>,
1832 {
1833 #[inline]
1834 fn encode_option(
1835 this: ::core::option::Option<Self>,
1836 encoder: &mut ___E,
1837 out: &mut ::core::mem::MaybeUninit<
1838 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreImportRequest<'static>>,
1839 >,
1840 _: (),
1841 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1842 if let Some(inner) = this {
1843 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1844 ::fidl_next::wire::Box::encode_present(out);
1845 } else {
1846 ::fidl_next::wire::Box::encode_absent(out);
1847 }
1848
1849 Ok(())
1850 }
1851 }
1852
1853 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
1854 for CapabilityStoreImportRequest
1855 {
1856 #[inline]
1857 fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
1858 Self {
1859 id: ::fidl_next::FromWire::from_wire(wire.id),
1860
1861 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1862 }
1863 }
1864 }
1865
1866 #[derive(Debug, Default, PartialEq)]
1867 pub struct CapabilityStoreDirConnectorOpenRequest {
1868 pub id: ::core::option::Option<u64>,
1869
1870 pub server_end: ::core::option::Option<
1871 ::fidl_next::ServerEnd<
1872 ::fidl_next_fuchsia_io::Directory,
1873 ::fidl_next::fuchsia::zx::Channel,
1874 >,
1875 >,
1876
1877 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
1878
1879 pub path: ::core::option::Option<::std::string::String>,
1880 }
1881
1882 impl CapabilityStoreDirConnectorOpenRequest {
1883 fn __max_ordinal(&self) -> usize {
1884 if self.path.is_some() {
1885 return 4;
1886 }
1887
1888 if self.flags.is_some() {
1889 return 3;
1890 }
1891
1892 if self.server_end.is_some() {
1893 return 2;
1894 }
1895
1896 if self.id.is_some() {
1897 return 1;
1898 }
1899
1900 0
1901 }
1902 }
1903
1904 unsafe impl<___E>
1905 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>, ___E>
1906 for CapabilityStoreDirConnectorOpenRequest
1907 where
1908 ___E: ::fidl_next::Encoder + ?Sized,
1909 ___E: ::fidl_next::fuchsia::HandleEncoder,
1910 {
1911 #[inline]
1912 fn encode(
1913 mut self,
1914 encoder: &mut ___E,
1915 out: &mut ::core::mem::MaybeUninit<
1916 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
1917 >,
1918 _: (),
1919 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1920 ::fidl_next::munge!(let crate::wire::CapabilityStoreDirConnectorOpenRequest { table } = out);
1921
1922 let max_ord = self.__max_ordinal();
1923
1924 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1925 ::fidl_next::Wire::zero_padding(&mut out);
1926
1927 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1928 ::fidl_next::wire::Envelope,
1929 >(encoder, max_ord);
1930
1931 for i in 1..=max_ord {
1932 match i {
1933 4 => {
1934 if let Some(value) = self.path.take() {
1935 ::fidl_next::wire::Envelope::encode_value::<
1936 ::fidl_next::wire::String<'static>,
1937 ___E,
1938 >(
1939 value, preallocated.encoder, &mut out, 4095
1940 )?;
1941 } else {
1942 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1943 }
1944 }
1945
1946 3 => {
1947 if let Some(value) = self.flags.take() {
1948 ::fidl_next::wire::Envelope::encode_value::<
1949 ::fidl_next_fuchsia_io::wire::Flags,
1950 ___E,
1951 >(
1952 value, preallocated.encoder, &mut out, ()
1953 )?;
1954 } else {
1955 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1956 }
1957 }
1958
1959 2 => {
1960 if let Some(value) = self.server_end.take() {
1961 ::fidl_next::wire::Envelope::encode_value::<
1962 ::fidl_next::ServerEnd<
1963 ::fidl_next_fuchsia_io::Directory,
1964 ::fidl_next::wire::fuchsia::Channel,
1965 >,
1966 ___E,
1967 >(
1968 value, preallocated.encoder, &mut out, ()
1969 )?;
1970 } else {
1971 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1972 }
1973 }
1974
1975 1 => {
1976 if let Some(value) = self.id.take() {
1977 ::fidl_next::wire::Envelope::encode_value::<
1978 ::fidl_next::wire::Uint64,
1979 ___E,
1980 >(
1981 value, preallocated.encoder, &mut out, ()
1982 )?;
1983 } else {
1984 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1985 }
1986 }
1987
1988 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1989 }
1990 unsafe {
1991 preallocated.write_next(out.assume_init_ref());
1992 }
1993 }
1994
1995 ::fidl_next::wire::Table::encode_len(table, max_ord);
1996
1997 Ok(())
1998 }
1999 }
2000
2001 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>>
2002 for CapabilityStoreDirConnectorOpenRequest
2003 {
2004 #[inline]
2005 fn from_wire(wire_: crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>) -> Self {
2006 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2007
2008 let id = wire_.table.get(1);
2009
2010 let server_end = wire_.table.get(2);
2011
2012 let flags = wire_.table.get(3);
2013
2014 let path = wire_.table.get(4);
2015
2016 Self {
2017 id: id.map(|envelope| {
2018 ::fidl_next::FromWire::from_wire(unsafe {
2019 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2020 })
2021 }),
2022
2023 server_end: server_end.map(|envelope| {
2024 ::fidl_next::FromWire::from_wire(unsafe {
2025 envelope.read_unchecked::<::fidl_next::ServerEnd<
2026 ::fidl_next_fuchsia_io::Directory,
2027 ::fidl_next::wire::fuchsia::Channel,
2028 >>()
2029 })
2030 }),
2031
2032 flags: flags.map(|envelope| {
2033 ::fidl_next::FromWire::from_wire(unsafe {
2034 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
2035 })
2036 }),
2037
2038 path: path.map(|envelope| {
2039 ::fidl_next::FromWire::from_wire(unsafe {
2040 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
2041 })
2042 }),
2043 }
2044 }
2045 }
2046
2047 #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
2048 #[derive(Debug, PartialEq)]
2049 #[repr(C)]
2050 pub struct InstanceToken {
2051 pub token: ::fidl_next::fuchsia::zx::EventPair,
2052 }
2053
2054 unsafe impl<___E> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken
2055 where
2056 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2057 ___E: ::fidl_next::fuchsia::HandleEncoder,
2058 {
2059 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
2060 ::fidl_next::CopyOptimization::enable_if(
2061 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2062 ::fidl_next::wire::fuchsia::EventPair,
2063 ___E,
2064 >>::COPY_OPTIMIZATION
2065 .is_enabled(),
2066 )
2067 };
2068
2069 #[inline]
2070 fn encode(
2071 self,
2072 encoder_: &mut ___E,
2073 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
2074 _: (),
2075 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2076 ::fidl_next::munge! {
2077 let crate::wire::InstanceToken {
2078 token,
2079
2080 } = out_;
2081 }
2082
2083 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
2084
2085 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
2086
2087 Ok(())
2088 }
2089 }
2090
2091 unsafe impl<___E>
2092 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::InstanceToken>, ___E>
2093 for InstanceToken
2094 where
2095 ___E: ::fidl_next::Encoder + ?Sized,
2096 InstanceToken: ::fidl_next::Encode<crate::wire::InstanceToken, ___E>,
2097 {
2098 #[inline]
2099 fn encode_option(
2100 this: ::core::option::Option<Self>,
2101 encoder: &mut ___E,
2102 out: &mut ::core::mem::MaybeUninit<
2103 ::fidl_next::wire::Box<'static, crate::wire::InstanceToken>,
2104 >,
2105 _: (),
2106 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2107 if let Some(inner) = this {
2108 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2109 ::fidl_next::wire::Box::encode_present(out);
2110 } else {
2111 ::fidl_next::wire::Box::encode_absent(out);
2112 }
2113
2114 Ok(())
2115 }
2116 }
2117
2118 impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
2119 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
2120 ::fidl_next::CopyOptimization::enable_if(
2121 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2122 ::fidl_next::wire::fuchsia::EventPair,
2123 >>::COPY_OPTIMIZATION
2124 .is_enabled(),
2125 )
2126 };
2127
2128 #[inline]
2129 fn from_wire(wire: crate::wire::InstanceToken) -> Self {
2130 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
2131 }
2132 }
2133
2134 #[doc = " A request for a route.\n"]
2135 #[derive(Debug, Default, PartialEq)]
2136 pub struct RouteRequest {
2137 pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
2138 }
2139
2140 impl RouteRequest {
2141 fn __max_ordinal(&self) -> usize {
2142 if self.requesting.is_some() {
2143 return 1;
2144 }
2145
2146 0
2147 }
2148 }
2149
2150 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouteRequest<'static>, ___E> for RouteRequest
2151 where
2152 ___E: ::fidl_next::Encoder + ?Sized,
2153 ___E: ::fidl_next::fuchsia::HandleEncoder,
2154 {
2155 #[inline]
2156 fn encode(
2157 mut self,
2158 encoder: &mut ___E,
2159 out: &mut ::core::mem::MaybeUninit<crate::wire::RouteRequest<'static>>,
2160 _: (),
2161 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2162 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
2163
2164 let max_ord = self.__max_ordinal();
2165
2166 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2167 ::fidl_next::Wire::zero_padding(&mut out);
2168
2169 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2170 ::fidl_next::wire::Envelope,
2171 >(encoder, max_ord);
2172
2173 for i in 1..=max_ord {
2174 match i {
2175 1 => {
2176 if let Some(value) = self.requesting.take() {
2177 ::fidl_next::wire::Envelope::encode_value::<
2178 crate::wire::InstanceToken,
2179 ___E,
2180 >(
2181 value, preallocated.encoder, &mut out, ()
2182 )?;
2183 } else {
2184 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2185 }
2186 }
2187
2188 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2189 }
2190 unsafe {
2191 preallocated.write_next(out.assume_init_ref());
2192 }
2193 }
2194
2195 ::fidl_next::wire::Table::encode_len(table, max_ord);
2196
2197 Ok(())
2198 }
2199 }
2200
2201 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
2202 #[inline]
2203 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
2204 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2205
2206 let requesting = wire_.table.get(1);
2207
2208 Self {
2209 requesting: requesting.map(|envelope| {
2210 ::fidl_next::FromWire::from_wire(unsafe {
2211 envelope.read_unchecked::<crate::wire::InstanceToken>()
2212 })
2213 }),
2214 }
2215 }
2216 }
2217
2218 #[derive(Debug, PartialEq)]
2219 pub enum ConnectorRouterRouteResponse {
2220 Connector(crate::natural::Connector),
2221
2222 Unavailable(crate::natural::Unit),
2223 }
2224
2225 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>
2226 for ConnectorRouterRouteResponse
2227 where
2228 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2229 ___E: ::fidl_next::fuchsia::HandleEncoder,
2230 {
2231 #[inline]
2232 fn encode(
2233 self,
2234 encoder: &mut ___E,
2235 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectorRouterRouteResponse>,
2236 _: (),
2237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2238 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2239
2240 match self {
2241 Self::Connector(value) => ::fidl_next::wire::Union::encode_as_static::<
2242 ___E,
2243 crate::wire::Connector,
2244 >(value, 1, encoder, raw, ())?,
2245
2246 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2247 ___E,
2248 crate::wire::Unit,
2249 >(value, 2, encoder, raw, ())?,
2250 }
2251
2252 Ok(())
2253 }
2254 }
2255
2256 unsafe impl<___E>
2257 ::fidl_next::EncodeOption<crate::wire_optional::ConnectorRouterRouteResponse, ___E>
2258 for ConnectorRouterRouteResponse
2259 where
2260 ___E: ?Sized,
2261 ConnectorRouterRouteResponse:
2262 ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>,
2263 {
2264 #[inline]
2265 fn encode_option(
2266 this: ::core::option::Option<Self>,
2267 encoder: &mut ___E,
2268 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConnectorRouterRouteResponse>,
2269 _: (),
2270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2271 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2272
2273 if let Some(inner) = this {
2274 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2275 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2276 } else {
2277 ::fidl_next::wire::Union::encode_absent(raw);
2278 }
2279
2280 Ok(())
2281 }
2282 }
2283
2284 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
2285 for ConnectorRouterRouteResponse
2286 {
2287 #[inline]
2288 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
2289 let wire = ::core::mem::ManuallyDrop::new(wire);
2290 match wire.raw.ordinal() {
2291 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
2292 wire.raw.get().read_unchecked::<crate::wire::Connector>()
2293 })),
2294
2295 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2296 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2297 })),
2298
2299 _ => unsafe { ::core::hint::unreachable_unchecked() },
2300 }
2301 }
2302 }
2303
2304 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2305 for ConnectorRouterRouteResponse
2306 {
2307 #[inline]
2308 fn from_wire_option(
2309 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2310 ) -> ::core::option::Option<Self> {
2311 if let Some(inner) = wire.into_option() {
2312 Some(::fidl_next::FromWire::from_wire(inner))
2313 } else {
2314 None
2315 }
2316 }
2317 }
2318
2319 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2320 for Box<ConnectorRouterRouteResponse>
2321 {
2322 #[inline]
2323 fn from_wire_option(
2324 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2325 ) -> ::core::option::Option<Self> {
2326 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
2327 crate::wire_optional::ConnectorRouterRouteResponse,
2328 >>::from_wire_option(wire)
2329 .map(Box::new)
2330 }
2331 }
2332
2333 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2334 pub enum DataRouterRouteResponse {
2335 Data(crate::natural::Data),
2336
2337 Unavailable(crate::natural::Unit),
2338 }
2339
2340 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>
2341 for DataRouterRouteResponse
2342 where
2343 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2344 ___E: ::fidl_next::Encoder,
2345 ___E: ::fidl_next::fuchsia::HandleEncoder,
2346 {
2347 #[inline]
2348 fn encode(
2349 self,
2350 encoder: &mut ___E,
2351 out: &mut ::core::mem::MaybeUninit<crate::wire::DataRouterRouteResponse<'static>>,
2352 _: (),
2353 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2354 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
2355
2356 match self {
2357 Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
2358 ___E,
2359 crate::wire::Data<'static>,
2360 >(value, 1, encoder, raw, ())?,
2361
2362 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as::<
2363 ___E,
2364 crate::wire::Unit,
2365 >(value, 2, encoder, raw, ())?,
2366 }
2367
2368 Ok(())
2369 }
2370 }
2371
2372 unsafe impl<___E>
2373 ::fidl_next::EncodeOption<crate::wire_optional::DataRouterRouteResponse<'static>, ___E>
2374 for DataRouterRouteResponse
2375 where
2376 ___E: ?Sized,
2377 DataRouterRouteResponse:
2378 ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>,
2379 {
2380 #[inline]
2381 fn encode_option(
2382 this: ::core::option::Option<Self>,
2383 encoder: &mut ___E,
2384 out: &mut ::core::mem::MaybeUninit<
2385 crate::wire_optional::DataRouterRouteResponse<'static>,
2386 >,
2387 _: (),
2388 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2389 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2390
2391 if let Some(inner) = this {
2392 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2393 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2394 } else {
2395 ::fidl_next::wire::Union::encode_absent(raw);
2396 }
2397
2398 Ok(())
2399 }
2400 }
2401
2402 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
2403 for DataRouterRouteResponse
2404 {
2405 #[inline]
2406 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
2407 let wire = ::core::mem::ManuallyDrop::new(wire);
2408 match wire.raw.ordinal() {
2409 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
2410 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
2411 })),
2412
2413 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2414 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2415 })),
2416
2417 _ => unsafe { ::core::hint::unreachable_unchecked() },
2418 }
2419 }
2420 }
2421
2422 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2423 for DataRouterRouteResponse
2424 {
2425 #[inline]
2426 fn from_wire_option(
2427 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2428 ) -> ::core::option::Option<Self> {
2429 if let Some(inner) = wire.into_option() {
2430 Some(::fidl_next::FromWire::from_wire(inner))
2431 } else {
2432 None
2433 }
2434 }
2435 }
2436
2437 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2438 for Box<DataRouterRouteResponse>
2439 {
2440 #[inline]
2441 fn from_wire_option(
2442 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2443 ) -> ::core::option::Option<Self> {
2444 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
2445 crate::wire_optional::DataRouterRouteResponse<'de>,
2446 >>::from_wire_option(wire)
2447 .map(Box::new)
2448 }
2449 }
2450
2451 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2452 pub struct DictionaryDrainIteratorGetNextResponse {
2453 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
2454
2455 pub end_id: u64,
2456 }
2457
2458 unsafe impl<___E>
2459 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
2460 for DictionaryDrainIteratorGetNextResponse
2461 where
2462 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2463 ___E: ::fidl_next::Encoder,
2464 ___E: ::fidl_next::fuchsia::HandleEncoder,
2465 {
2466 #[inline]
2467 fn encode(
2468 self,
2469 encoder_: &mut ___E,
2470 out_: &mut ::core::mem::MaybeUninit<
2471 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2472 >,
2473 _: (),
2474 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2475 ::fidl_next::munge! {
2476 let crate::wire::DictionaryDrainIteratorGetNextResponse {
2477 items,
2478 end_id,
2479
2480 } = out_;
2481 }
2482
2483 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2484
2485 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2486 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2487
2488 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2489
2490 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2491
2492 Ok(())
2493 }
2494 }
2495
2496 unsafe impl<___E>
2497 ::fidl_next::EncodeOption<
2498 ::fidl_next::wire::Box<
2499 'static,
2500 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2501 >,
2502 ___E,
2503 > for DictionaryDrainIteratorGetNextResponse
2504 where
2505 ___E: ::fidl_next::Encoder + ?Sized,
2506 DictionaryDrainIteratorGetNextResponse:
2507 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>,
2508 {
2509 #[inline]
2510 fn encode_option(
2511 this: ::core::option::Option<Self>,
2512 encoder: &mut ___E,
2513 out: &mut ::core::mem::MaybeUninit<
2514 ::fidl_next::wire::Box<
2515 'static,
2516 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2517 >,
2518 >,
2519 _: (),
2520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2521 if let Some(inner) = this {
2522 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2523 ::fidl_next::wire::Box::encode_present(out);
2524 } else {
2525 ::fidl_next::wire::Box::encode_absent(out);
2526 }
2527
2528 Ok(())
2529 }
2530 }
2531
2532 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
2533 for DictionaryDrainIteratorGetNextResponse
2534 {
2535 #[inline]
2536 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
2537 Self {
2538 items: ::fidl_next::FromWire::from_wire(wire.items),
2539
2540 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2541 }
2542 }
2543 }
2544
2545 #[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"]
2546 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2547 pub struct DictionaryOptionalItem {
2548 pub key: ::std::string::String,
2549
2550 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
2551 }
2552
2553 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
2554 for DictionaryOptionalItem
2555 where
2556 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2557 ___E: ::fidl_next::Encoder,
2558 ___E: ::fidl_next::fuchsia::HandleEncoder,
2559 {
2560 #[inline]
2561 fn encode(
2562 self,
2563 encoder_: &mut ___E,
2564 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
2565 _: (),
2566 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2567 ::fidl_next::munge! {
2568 let crate::wire::DictionaryOptionalItem {
2569 key,
2570 value,
2571
2572 } = out_;
2573 }
2574
2575 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2576
2577 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2578 ::fidl_next::Constrained::validate(_field, 255)?;
2579
2580 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2581
2582 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2583
2584 Ok(())
2585 }
2586 }
2587
2588 unsafe impl<___E>
2589 ::fidl_next::EncodeOption<
2590 ::fidl_next::wire::Box<'static, crate::wire::DictionaryOptionalItem<'static>>,
2591 ___E,
2592 > for DictionaryOptionalItem
2593 where
2594 ___E: ::fidl_next::Encoder + ?Sized,
2595 DictionaryOptionalItem:
2596 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>,
2597 {
2598 #[inline]
2599 fn encode_option(
2600 this: ::core::option::Option<Self>,
2601 encoder: &mut ___E,
2602 out: &mut ::core::mem::MaybeUninit<
2603 ::fidl_next::wire::Box<'static, crate::wire::DictionaryOptionalItem<'static>>,
2604 >,
2605 _: (),
2606 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2607 if let Some(inner) = this {
2608 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2609 ::fidl_next::wire::Box::encode_present(out);
2610 } else {
2611 ::fidl_next::wire::Box::encode_absent(out);
2612 }
2613
2614 Ok(())
2615 }
2616 }
2617
2618 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
2619 for DictionaryOptionalItem
2620 {
2621 #[inline]
2622 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
2623 Self {
2624 key: ::fidl_next::FromWire::from_wire(wire.key),
2625
2626 value: ::fidl_next::FromWire::from_wire(wire.value),
2627 }
2628 }
2629 }
2630
2631 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2632 pub struct DictionaryEnumerateIteratorGetNextResponse {
2633 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
2634
2635 pub end_id: u64,
2636 }
2637
2638 unsafe impl<___E>
2639 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
2640 for DictionaryEnumerateIteratorGetNextResponse
2641 where
2642 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2643 ___E: ::fidl_next::Encoder,
2644 ___E: ::fidl_next::fuchsia::HandleEncoder,
2645 {
2646 #[inline]
2647 fn encode(
2648 self,
2649 encoder_: &mut ___E,
2650 out_: &mut ::core::mem::MaybeUninit<
2651 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2652 >,
2653 _: (),
2654 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2655 ::fidl_next::munge! {
2656 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
2657 items,
2658 end_id,
2659
2660 } = out_;
2661 }
2662
2663 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2664
2665 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2666 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2667
2668 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2669
2670 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2671
2672 Ok(())
2673 }
2674 }
2675
2676 unsafe impl<___E>
2677 ::fidl_next::EncodeOption<
2678 ::fidl_next::wire::Box<
2679 'static,
2680 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2681 >,
2682 ___E,
2683 > for DictionaryEnumerateIteratorGetNextResponse
2684 where
2685 ___E: ::fidl_next::Encoder + ?Sized,
2686 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<
2687 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2688 ___E,
2689 >,
2690 {
2691 #[inline]
2692 fn encode_option(
2693 this: ::core::option::Option<Self>,
2694 encoder: &mut ___E,
2695 out: &mut ::core::mem::MaybeUninit<
2696 ::fidl_next::wire::Box<
2697 'static,
2698 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2699 >,
2700 >,
2701 _: (),
2702 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2703 if let Some(inner) = this {
2704 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2705 ::fidl_next::wire::Box::encode_present(out);
2706 } else {
2707 ::fidl_next::wire::Box::encode_absent(out);
2708 }
2709
2710 Ok(())
2711 }
2712 }
2713
2714 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
2715 for DictionaryEnumerateIteratorGetNextResponse
2716 {
2717 #[inline]
2718 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
2719 Self {
2720 items: ::fidl_next::FromWire::from_wire(wire.items),
2721
2722 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2723 }
2724 }
2725 }
2726
2727 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2728 pub struct DictionaryKeysIteratorGetNextResponse {
2729 pub keys: ::std::vec::Vec<::std::string::String>,
2730 }
2731
2732 unsafe impl<___E>
2733 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
2734 for DictionaryKeysIteratorGetNextResponse
2735 where
2736 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2737 ___E: ::fidl_next::Encoder,
2738 ___E: ::fidl_next::fuchsia::HandleEncoder,
2739 {
2740 #[inline]
2741 fn encode(
2742 self,
2743 encoder_: &mut ___E,
2744 out_: &mut ::core::mem::MaybeUninit<
2745 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2746 >,
2747 _: (),
2748 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2749 ::fidl_next::munge! {
2750 let crate::wire::DictionaryKeysIteratorGetNextResponse {
2751 keys,
2752
2753 } = out_;
2754 }
2755
2756 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
2757
2758 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
2759 ::fidl_next::Constrained::validate(_field, (128, 255))?;
2760
2761 Ok(())
2762 }
2763 }
2764
2765 unsafe impl<___E>
2766 ::fidl_next::EncodeOption<
2767 ::fidl_next::wire::Box<
2768 'static,
2769 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2770 >,
2771 ___E,
2772 > for DictionaryKeysIteratorGetNextResponse
2773 where
2774 ___E: ::fidl_next::Encoder + ?Sized,
2775 DictionaryKeysIteratorGetNextResponse:
2776 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>,
2777 {
2778 #[inline]
2779 fn encode_option(
2780 this: ::core::option::Option<Self>,
2781 encoder: &mut ___E,
2782 out: &mut ::core::mem::MaybeUninit<
2783 ::fidl_next::wire::Box<
2784 'static,
2785 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2786 >,
2787 >,
2788 _: (),
2789 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2790 if let Some(inner) = this {
2791 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2792 ::fidl_next::wire::Box::encode_present(out);
2793 } else {
2794 ::fidl_next::wire::Box::encode_absent(out);
2795 }
2796
2797 Ok(())
2798 }
2799 }
2800
2801 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
2802 for DictionaryKeysIteratorGetNextResponse
2803 {
2804 #[inline]
2805 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
2806 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
2807 }
2808 }
2809
2810 #[derive(Debug, PartialEq)]
2811 pub enum DictionaryRouterRouteResponse {
2812 Dictionary(crate::natural::DictionaryRef),
2813
2814 Unavailable(crate::natural::Unit),
2815 }
2816
2817 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>
2818 for DictionaryRouterRouteResponse
2819 where
2820 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2821 ___E: ::fidl_next::fuchsia::HandleEncoder,
2822 {
2823 #[inline]
2824 fn encode(
2825 self,
2826 encoder: &mut ___E,
2827 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRouterRouteResponse>,
2828 _: (),
2829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2830 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
2831
2832 match self {
2833 Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as_static::<
2834 ___E,
2835 crate::wire::DictionaryRef,
2836 >(value, 1, encoder, raw, ())?,
2837
2838 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2839 ___E,
2840 crate::wire::Unit,
2841 >(value, 2, encoder, raw, ())?,
2842 }
2843
2844 Ok(())
2845 }
2846 }
2847
2848 unsafe impl<___E>
2849 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryRouterRouteResponse, ___E>
2850 for DictionaryRouterRouteResponse
2851 where
2852 ___E: ?Sized,
2853 DictionaryRouterRouteResponse:
2854 ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>,
2855 {
2856 #[inline]
2857 fn encode_option(
2858 this: ::core::option::Option<Self>,
2859 encoder: &mut ___E,
2860 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryRouterRouteResponse>,
2861 _: (),
2862 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2863 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2864
2865 if let Some(inner) = this {
2866 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2867 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2868 } else {
2869 ::fidl_next::wire::Union::encode_absent(raw);
2870 }
2871
2872 Ok(())
2873 }
2874 }
2875
2876 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
2877 for DictionaryRouterRouteResponse
2878 {
2879 #[inline]
2880 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
2881 let wire = ::core::mem::ManuallyDrop::new(wire);
2882 match wire.raw.ordinal() {
2883 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
2884 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
2885 })),
2886
2887 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2888 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2889 })),
2890
2891 _ => unsafe { ::core::hint::unreachable_unchecked() },
2892 }
2893 }
2894 }
2895
2896 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2897 for DictionaryRouterRouteResponse
2898 {
2899 #[inline]
2900 fn from_wire_option(
2901 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2902 ) -> ::core::option::Option<Self> {
2903 if let Some(inner) = wire.into_option() {
2904 Some(::fidl_next::FromWire::from_wire(inner))
2905 } else {
2906 None
2907 }
2908 }
2909 }
2910
2911 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2912 for Box<DictionaryRouterRouteResponse>
2913 {
2914 #[inline]
2915 fn from_wire_option(
2916 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2917 ) -> ::core::option::Option<Self> {
2918 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
2919 crate::wire_optional::DictionaryRouterRouteResponse,
2920 >>::from_wire_option(wire)
2921 .map(Box::new)
2922 }
2923 }
2924
2925 #[derive(Debug, PartialEq)]
2926 pub enum DirConnectorRouterRouteResponse {
2927 DirConnector(crate::natural::DirConnector),
2928
2929 Unavailable(crate::natural::Unit),
2930 }
2931
2932 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>
2933 for DirConnectorRouterRouteResponse
2934 where
2935 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2936 ___E: ::fidl_next::fuchsia::HandleEncoder,
2937 {
2938 #[inline]
2939 fn encode(
2940 self,
2941 encoder: &mut ___E,
2942 out: &mut ::core::mem::MaybeUninit<crate::wire::DirConnectorRouterRouteResponse>,
2943 _: (),
2944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2945 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2946
2947 match self {
2948 Self::DirConnector(value) => ::fidl_next::wire::Union::encode_as_static::<
2949 ___E,
2950 crate::wire::DirConnector,
2951 >(value, 1, encoder, raw, ())?,
2952
2953 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2954 ___E,
2955 crate::wire::Unit,
2956 >(value, 2, encoder, raw, ())?,
2957 }
2958
2959 Ok(())
2960 }
2961 }
2962
2963 unsafe impl<___E>
2964 ::fidl_next::EncodeOption<crate::wire_optional::DirConnectorRouterRouteResponse, ___E>
2965 for DirConnectorRouterRouteResponse
2966 where
2967 ___E: ?Sized,
2968 DirConnectorRouterRouteResponse:
2969 ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>,
2970 {
2971 #[inline]
2972 fn encode_option(
2973 this: ::core::option::Option<Self>,
2974 encoder: &mut ___E,
2975 out: &mut ::core::mem::MaybeUninit<
2976 crate::wire_optional::DirConnectorRouterRouteResponse,
2977 >,
2978 _: (),
2979 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2980 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2981
2982 if let Some(inner) = this {
2983 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2984 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2985 } else {
2986 ::fidl_next::wire::Union::encode_absent(raw);
2987 }
2988
2989 Ok(())
2990 }
2991 }
2992
2993 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
2994 for DirConnectorRouterRouteResponse
2995 {
2996 #[inline]
2997 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
2998 let wire = ::core::mem::ManuallyDrop::new(wire);
2999 match wire.raw.ordinal() {
3000 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
3001 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
3002 })),
3003
3004 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3005 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3006 })),
3007
3008 _ => unsafe { ::core::hint::unreachable_unchecked() },
3009 }
3010 }
3011 }
3012
3013 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3014 for DirConnectorRouterRouteResponse
3015 {
3016 #[inline]
3017 fn from_wire_option(
3018 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3019 ) -> ::core::option::Option<Self> {
3020 if let Some(inner) = wire.into_option() {
3021 Some(::fidl_next::FromWire::from_wire(inner))
3022 } else {
3023 None
3024 }
3025 }
3026 }
3027
3028 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3029 for Box<DirConnectorRouterRouteResponse>
3030 {
3031 #[inline]
3032 fn from_wire_option(
3033 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3034 ) -> ::core::option::Option<Self> {
3035 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
3036 crate::wire_optional::DirConnectorRouterRouteResponse,
3037 >>::from_wire_option(wire)
3038 .map(Box::new)
3039 }
3040 }
3041
3042 #[derive(Debug, PartialEq)]
3043 pub enum DirEntryRouterRouteResponse {
3044 DirEntry(crate::natural::DirEntry),
3045
3046 Unavailable(crate::natural::Unit),
3047 }
3048
3049 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>
3050 for DirEntryRouterRouteResponse
3051 where
3052 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3053 ___E: ::fidl_next::fuchsia::HandleEncoder,
3054 {
3055 #[inline]
3056 fn encode(
3057 self,
3058 encoder: &mut ___E,
3059 out: &mut ::core::mem::MaybeUninit<crate::wire::DirEntryRouterRouteResponse>,
3060 _: (),
3061 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3062 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
3063
3064 match self {
3065 Self::DirEntry(value) => ::fidl_next::wire::Union::encode_as_static::<
3066 ___E,
3067 crate::wire::DirEntry,
3068 >(value, 1, encoder, raw, ())?,
3069
3070 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
3071 ___E,
3072 crate::wire::Unit,
3073 >(value, 2, encoder, raw, ())?,
3074 }
3075
3076 Ok(())
3077 }
3078 }
3079
3080 unsafe impl<___E>
3081 ::fidl_next::EncodeOption<crate::wire_optional::DirEntryRouterRouteResponse, ___E>
3082 for DirEntryRouterRouteResponse
3083 where
3084 ___E: ?Sized,
3085 DirEntryRouterRouteResponse:
3086 ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>,
3087 {
3088 #[inline]
3089 fn encode_option(
3090 this: ::core::option::Option<Self>,
3091 encoder: &mut ___E,
3092 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirEntryRouterRouteResponse>,
3093 _: (),
3094 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3095 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3096
3097 if let Some(inner) = this {
3098 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3099 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3100 } else {
3101 ::fidl_next::wire::Union::encode_absent(raw);
3102 }
3103
3104 Ok(())
3105 }
3106 }
3107
3108 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
3109 for DirEntryRouterRouteResponse
3110 {
3111 #[inline]
3112 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
3113 let wire = ::core::mem::ManuallyDrop::new(wire);
3114 match wire.raw.ordinal() {
3115 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
3116 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
3117 })),
3118
3119 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3120 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3121 })),
3122
3123 _ => unsafe { ::core::hint::unreachable_unchecked() },
3124 }
3125 }
3126 }
3127
3128 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3129 for DirEntryRouterRouteResponse
3130 {
3131 #[inline]
3132 fn from_wire_option(
3133 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3134 ) -> ::core::option::Option<Self> {
3135 if let Some(inner) = wire.into_option() {
3136 Some(::fidl_next::FromWire::from_wire(inner))
3137 } else {
3138 None
3139 }
3140 }
3141 }
3142
3143 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3144 for Box<DirEntryRouterRouteResponse>
3145 {
3146 #[inline]
3147 fn from_wire_option(
3148 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3149 ) -> ::core::option::Option<Self> {
3150 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
3151 crate::wire_optional::DirEntryRouterRouteResponse,
3152 >>::from_wire_option(wire)
3153 .map(Box::new)
3154 }
3155 }
3156
3157 #[derive(Debug, Default, PartialEq)]
3158 pub struct DirReceiverReceiveRequest {
3159 pub channel: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
3160
3161 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
3162
3163 pub subdir: ::core::option::Option<::std::string::String>,
3164 }
3165
3166 impl DirReceiverReceiveRequest {
3167 fn __max_ordinal(&self) -> usize {
3168 if self.subdir.is_some() {
3169 return 3;
3170 }
3171
3172 if self.flags.is_some() {
3173 return 2;
3174 }
3175
3176 if self.channel.is_some() {
3177 return 1;
3178 }
3179
3180 0
3181 }
3182 }
3183
3184 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest<'static>, ___E>
3185 for DirReceiverReceiveRequest
3186 where
3187 ___E: ::fidl_next::Encoder + ?Sized,
3188 ___E: ::fidl_next::fuchsia::HandleEncoder,
3189 {
3190 #[inline]
3191 fn encode(
3192 mut self,
3193 encoder: &mut ___E,
3194 out: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest<'static>>,
3195 _: (),
3196 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3197 ::fidl_next::munge!(let crate::wire::DirReceiverReceiveRequest { table } = out);
3198
3199 let max_ord = self.__max_ordinal();
3200
3201 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
3202 ::fidl_next::Wire::zero_padding(&mut out);
3203
3204 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
3205 ::fidl_next::wire::Envelope,
3206 >(encoder, max_ord);
3207
3208 for i in 1..=max_ord {
3209 match i {
3210 3 => {
3211 if let Some(value) = self.subdir.take() {
3212 ::fidl_next::wire::Envelope::encode_value::<
3213 ::fidl_next::wire::String<'static>,
3214 ___E,
3215 >(
3216 value, preallocated.encoder, &mut out, 4095
3217 )?;
3218 } else {
3219 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3220 }
3221 }
3222
3223 2 => {
3224 if let Some(value) = self.flags.take() {
3225 ::fidl_next::wire::Envelope::encode_value::<
3226 ::fidl_next_fuchsia_io::wire::Flags,
3227 ___E,
3228 >(
3229 value, preallocated.encoder, &mut out, ()
3230 )?;
3231 } else {
3232 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3233 }
3234 }
3235
3236 1 => {
3237 if let Some(value) = self.channel.take() {
3238 ::fidl_next::wire::Envelope::encode_value::<
3239 ::fidl_next::wire::fuchsia::Channel,
3240 ___E,
3241 >(
3242 value, preallocated.encoder, &mut out, ()
3243 )?;
3244 } else {
3245 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3246 }
3247 }
3248
3249 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
3250 }
3251 unsafe {
3252 preallocated.write_next(out.assume_init_ref());
3253 }
3254 }
3255
3256 ::fidl_next::wire::Table::encode_len(table, max_ord);
3257
3258 Ok(())
3259 }
3260 }
3261
3262 impl<'de> ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest<'de>>
3263 for DirReceiverReceiveRequest
3264 {
3265 #[inline]
3266 fn from_wire(wire_: crate::wire::DirReceiverReceiveRequest<'de>) -> Self {
3267 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
3268
3269 let channel = wire_.table.get(1);
3270
3271 let flags = wire_.table.get(2);
3272
3273 let subdir = wire_.table.get(3);
3274
3275 Self {
3276 channel: channel.map(|envelope| {
3277 ::fidl_next::FromWire::from_wire(unsafe {
3278 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3279 })
3280 }),
3281
3282 flags: flags.map(|envelope| {
3283 ::fidl_next::FromWire::from_wire(unsafe {
3284 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
3285 })
3286 }),
3287
3288 subdir: subdir.map(|envelope| {
3289 ::fidl_next::FromWire::from_wire(unsafe {
3290 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3291 })
3292 }),
3293 }
3294 }
3295 }
3296
3297 #[derive(Debug, PartialEq)]
3298 pub enum DirectoryRouterRouteResponse {
3299 Directory(
3300 ::fidl_next::ClientEnd<
3301 ::fidl_next_fuchsia_io::Directory,
3302 ::fidl_next::fuchsia::zx::Channel,
3303 >,
3304 ),
3305
3306 Unavailable(crate::natural::Unit),
3307 }
3308
3309 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>
3310 for DirectoryRouterRouteResponse
3311 where
3312 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3313 ___E: ::fidl_next::fuchsia::HandleEncoder,
3314 {
3315 #[inline]
3316 fn encode(
3317 self,
3318 encoder: &mut ___E,
3319 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRouterRouteResponse>,
3320 _: (),
3321 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3322 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
3323
3324 match self {
3325 Self::Directory(value) => ::fidl_next::wire::Union::encode_as_static::<
3326 ___E,
3327 ::fidl_next::ClientEnd<
3328 ::fidl_next_fuchsia_io::Directory,
3329 ::fidl_next::wire::fuchsia::Channel,
3330 >,
3331 >(value, 1, encoder, raw, ())?,
3332
3333 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
3334 ___E,
3335 crate::wire::Unit,
3336 >(value, 2, encoder, raw, ())?,
3337 }
3338
3339 Ok(())
3340 }
3341 }
3342
3343 unsafe impl<___E>
3344 ::fidl_next::EncodeOption<crate::wire_optional::DirectoryRouterRouteResponse, ___E>
3345 for DirectoryRouterRouteResponse
3346 where
3347 ___E: ?Sized,
3348 DirectoryRouterRouteResponse:
3349 ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>,
3350 {
3351 #[inline]
3352 fn encode_option(
3353 this: ::core::option::Option<Self>,
3354 encoder: &mut ___E,
3355 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirectoryRouterRouteResponse>,
3356 _: (),
3357 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3358 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3359
3360 if let Some(inner) = this {
3361 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3362 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3363 } else {
3364 ::fidl_next::wire::Union::encode_absent(raw);
3365 }
3366
3367 Ok(())
3368 }
3369 }
3370
3371 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
3372 for DirectoryRouterRouteResponse
3373 {
3374 #[inline]
3375 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
3376 let wire = ::core::mem::ManuallyDrop::new(wire);
3377 match wire.raw.ordinal() {
3378 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
3379 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3380 ::fidl_next_fuchsia_io::Directory,
3381 ::fidl_next::wire::fuchsia::Channel,
3382 >>()
3383 })),
3384
3385 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3386 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3387 })),
3388
3389 _ => unsafe { ::core::hint::unreachable_unchecked() },
3390 }
3391 }
3392 }
3393
3394 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3395 for DirectoryRouterRouteResponse
3396 {
3397 #[inline]
3398 fn from_wire_option(
3399 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3400 ) -> ::core::option::Option<Self> {
3401 if let Some(inner) = wire.into_option() {
3402 Some(::fidl_next::FromWire::from_wire(inner))
3403 } else {
3404 None
3405 }
3406 }
3407 }
3408
3409 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3410 for Box<DirectoryRouterRouteResponse>
3411 {
3412 #[inline]
3413 fn from_wire_option(
3414 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3415 ) -> ::core::option::Option<Self> {
3416 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
3417 crate::wire_optional::DirectoryRouterRouteResponse,
3418 >>::from_wire_option(wire)
3419 .map(Box::new)
3420 }
3421 }
3422
3423 #[doc = " Contains a protocol open request.\n"]
3424 #[derive(Debug, PartialEq)]
3425 #[repr(C)]
3426 pub struct ProtocolPayload {
3427 pub channel: ::fidl_next::fuchsia::zx::Channel,
3428 }
3429
3430 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E> for ProtocolPayload
3431 where
3432 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3433 ___E: ::fidl_next::fuchsia::HandleEncoder,
3434 {
3435 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
3436 ::fidl_next::CopyOptimization::enable_if(
3437 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
3438 ::fidl_next::wire::fuchsia::Channel,
3439 ___E,
3440 >>::COPY_OPTIMIZATION
3441 .is_enabled(),
3442 )
3443 };
3444
3445 #[inline]
3446 fn encode(
3447 self,
3448 encoder_: &mut ___E,
3449 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
3450 _: (),
3451 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3452 ::fidl_next::munge! {
3453 let crate::wire::ProtocolPayload {
3454 channel,
3455
3456 } = out_;
3457 }
3458
3459 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3460
3461 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3462
3463 Ok(())
3464 }
3465 }
3466
3467 unsafe impl<___E>
3468 ::fidl_next::EncodeOption<
3469 ::fidl_next::wire::Box<'static, crate::wire::ProtocolPayload>,
3470 ___E,
3471 > for ProtocolPayload
3472 where
3473 ___E: ::fidl_next::Encoder + ?Sized,
3474 ProtocolPayload: ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>,
3475 {
3476 #[inline]
3477 fn encode_option(
3478 this: ::core::option::Option<Self>,
3479 encoder: &mut ___E,
3480 out: &mut ::core::mem::MaybeUninit<
3481 ::fidl_next::wire::Box<'static, crate::wire::ProtocolPayload>,
3482 >,
3483 _: (),
3484 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3485 if let Some(inner) = this {
3486 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3487 ::fidl_next::wire::Box::encode_present(out);
3488 } else {
3489 ::fidl_next::wire::Box::encode_absent(out);
3490 }
3491
3492 Ok(())
3493 }
3494 }
3495
3496 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
3497 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
3498 ::fidl_next::CopyOptimization::enable_if(
3499 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3500 ::fidl_next::wire::fuchsia::Channel,
3501 >>::COPY_OPTIMIZATION
3502 .is_enabled(),
3503 )
3504 };
3505
3506 #[inline]
3507 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
3508 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
3509 }
3510 }
3511}
3512
3513pub mod wire {
3514
3515 pub use fidl_next_common_fuchsia_component_sandbox::wire::*;
3516
3517 pub type Token = ::fidl_next::wire::fuchsia::EventPair;
3519
3520 #[derive(Debug)]
3522 #[repr(C)]
3523 pub struct DirConnector {
3524 pub token: ::fidl_next::wire::fuchsia::EventPair,
3525 }
3526
3527 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
3528 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
3529
3530 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
3531
3532 impl ::fidl_next::Constrained for DirConnector {
3533 type Constraint = ();
3534
3535 fn validate(
3536 _: ::fidl_next::Slot<'_, Self>,
3537 _: Self::Constraint,
3538 ) -> Result<(), ::fidl_next::ValidationError> {
3539 Ok(())
3540 }
3541 }
3542
3543 unsafe impl ::fidl_next::Wire for DirConnector {
3544 type Narrowed<'de> = DirConnector;
3545
3546 #[inline]
3547 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3548 ::fidl_next::munge! {
3549 let Self {
3550 token,
3551
3552 } = &mut *out_;
3553 }
3554
3555 ::fidl_next::Wire::zero_padding(token);
3556 }
3557 }
3558
3559 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
3560 where
3561 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3562 ___D: ::fidl_next::fuchsia::HandleDecoder,
3563 {
3564 fn decode(
3565 slot_: ::fidl_next::Slot<'_, Self>,
3566 decoder_: &mut ___D,
3567 _: (),
3568 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3569 ::fidl_next::munge! {
3570 let Self {
3571 mut token,
3572
3573 } = slot_;
3574 }
3575
3576 let _field = token.as_mut();
3577
3578 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3579
3580 Ok(())
3581 }
3582 }
3583
3584 impl ::fidl_next::IntoNatural for DirConnector {
3585 type Natural = crate::natural::DirConnector;
3586 }
3587
3588 #[repr(C)]
3590 pub struct AggregateSource<'de> {
3591 pub(crate) table: ::fidl_next::wire::Table<'de>,
3592 }
3593
3594 impl<'de> Drop for AggregateSource<'de> {
3595 fn drop(&mut self) {
3596 let _ = self
3597 .table
3598 .get(1)
3599 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DirConnector>() });
3600
3601 let _ = self.table.get(2)
3602 .map(|envelope| unsafe {
3603 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
3604 });
3605
3606 let _ = self.table.get(3).map(|envelope| unsafe {
3607 envelope.read_unchecked::<::fidl_next::wire::Vector<
3608 'de,
3609 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3610 >>()
3611 });
3612 }
3613 }
3614
3615 impl ::fidl_next::Constrained for AggregateSource<'_> {
3616 type Constraint = ();
3617
3618 fn validate(
3619 _: ::fidl_next::Slot<'_, Self>,
3620 _: Self::Constraint,
3621 ) -> Result<(), ::fidl_next::ValidationError> {
3622 Ok(())
3623 }
3624 }
3625
3626 unsafe impl ::fidl_next::Wire for AggregateSource<'static> {
3627 type Narrowed<'de> = AggregateSource<'de>;
3628
3629 #[inline]
3630 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3631 ::fidl_next::munge!(let Self { table } = out);
3632 ::fidl_next::wire::Table::zero_padding(table);
3633 }
3634 }
3635
3636 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AggregateSource<'de>
3637 where
3638 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3639 ___D: ::fidl_next::fuchsia::HandleDecoder,
3640 {
3641 fn decode(
3642 slot: ::fidl_next::Slot<'_, Self>,
3643 decoder: &mut ___D,
3644 _: (),
3645 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3646 ::fidl_next::munge!(let Self { table } = slot);
3647
3648 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3649 match ordinal {
3650 0 => unsafe { ::core::hint::unreachable_unchecked() },
3651
3652 1 => {
3653 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DirConnector>(
3654 slot.as_mut(),
3655 decoder,
3656 (),
3657 )?;
3658
3659 Ok(())
3660 }
3661
3662 2 => {
3663 ::fidl_next::wire::Envelope::decode_as::<
3664 ___D,
3665 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
3666 >(slot.as_mut(), decoder, (4294967295, 255))?;
3667
3668 Ok(())
3669 }
3670
3671 3 => {
3672 ::fidl_next::wire::Envelope::decode_as::<
3673 ___D,
3674 ::fidl_next::wire::Vector<
3675 'de,
3676 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3677 >,
3678 >(slot.as_mut(), decoder, (4294967295, ()))?;
3679
3680 Ok(())
3681 }
3682
3683 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3684 }
3685 })
3686 }
3687 }
3688
3689 impl<'de> AggregateSource<'de> {
3690 pub fn dir_connector(&self) -> ::core::option::Option<&crate::wire::DirConnector> {
3691 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3692 }
3693
3694 pub fn take_dir_connector(&mut self) -> ::core::option::Option<crate::wire::DirConnector> {
3695 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3696 }
3697
3698 pub fn source_instance_filter(
3699 &self,
3700 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>
3701 {
3702 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3703 }
3704
3705 pub fn take_source_instance_filter(
3706 &mut self,
3707 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>
3708 {
3709 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3710 }
3711
3712 pub fn renamed_instances(
3713 &self,
3714 ) -> ::core::option::Option<
3715 &::fidl_next::wire::Vector<
3716 'de,
3717 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3718 >,
3719 > {
3720 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3721 }
3722
3723 pub fn take_renamed_instances(
3724 &mut self,
3725 ) -> ::core::option::Option<
3726 ::fidl_next::wire::Vector<
3727 'de,
3728 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3729 >,
3730 > {
3731 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3732 }
3733 }
3734
3735 impl<'de> ::core::fmt::Debug for AggregateSource<'de> {
3736 fn fmt(
3737 &self,
3738 f: &mut ::core::fmt::Formatter<'_>,
3739 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3740 f.debug_struct("AggregateSource")
3741 .field("dir_connector", &self.dir_connector())
3742 .field("source_instance_filter", &self.source_instance_filter())
3743 .field("renamed_instances", &self.renamed_instances())
3744 .finish()
3745 }
3746 }
3747
3748 impl<'de> ::fidl_next::IntoNatural for AggregateSource<'de> {
3749 type Natural = crate::natural::AggregateSource;
3750 }
3751
3752 #[derive(Debug)]
3754 #[repr(C)]
3755 pub struct DictionaryRef {
3756 pub token: ::fidl_next::wire::fuchsia::EventPair,
3757 }
3758
3759 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
3760 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
3761
3762 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
3763
3764 impl ::fidl_next::Constrained for DictionaryRef {
3765 type Constraint = ();
3766
3767 fn validate(
3768 _: ::fidl_next::Slot<'_, Self>,
3769 _: Self::Constraint,
3770 ) -> Result<(), ::fidl_next::ValidationError> {
3771 Ok(())
3772 }
3773 }
3774
3775 unsafe impl ::fidl_next::Wire for DictionaryRef {
3776 type Narrowed<'de> = DictionaryRef;
3777
3778 #[inline]
3779 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3780 ::fidl_next::munge! {
3781 let Self {
3782 token,
3783
3784 } = &mut *out_;
3785 }
3786
3787 ::fidl_next::Wire::zero_padding(token);
3788 }
3789 }
3790
3791 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
3792 where
3793 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3794 ___D: ::fidl_next::fuchsia::HandleDecoder,
3795 {
3796 fn decode(
3797 slot_: ::fidl_next::Slot<'_, Self>,
3798 decoder_: &mut ___D,
3799 _: (),
3800 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3801 ::fidl_next::munge! {
3802 let Self {
3803 mut token,
3804
3805 } = slot_;
3806 }
3807
3808 let _field = token.as_mut();
3809
3810 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3811
3812 Ok(())
3813 }
3814 }
3815
3816 impl ::fidl_next::IntoNatural for DictionaryRef {
3817 type Natural = crate::natural::DictionaryRef;
3818 }
3819
3820 #[derive(Debug)]
3822 #[repr(C)]
3823 pub struct Connector {
3824 pub token: ::fidl_next::wire::fuchsia::EventPair,
3825 }
3826
3827 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
3828 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
3829
3830 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
3831
3832 impl ::fidl_next::Constrained for Connector {
3833 type Constraint = ();
3834
3835 fn validate(
3836 _: ::fidl_next::Slot<'_, Self>,
3837 _: Self::Constraint,
3838 ) -> Result<(), ::fidl_next::ValidationError> {
3839 Ok(())
3840 }
3841 }
3842
3843 unsafe impl ::fidl_next::Wire for Connector {
3844 type Narrowed<'de> = Connector;
3845
3846 #[inline]
3847 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3848 ::fidl_next::munge! {
3849 let Self {
3850 token,
3851
3852 } = &mut *out_;
3853 }
3854
3855 ::fidl_next::Wire::zero_padding(token);
3856 }
3857 }
3858
3859 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
3860 where
3861 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3862 ___D: ::fidl_next::fuchsia::HandleDecoder,
3863 {
3864 fn decode(
3865 slot_: ::fidl_next::Slot<'_, Self>,
3866 decoder_: &mut ___D,
3867 _: (),
3868 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3869 ::fidl_next::munge! {
3870 let Self {
3871 mut token,
3872
3873 } = slot_;
3874 }
3875
3876 let _field = token.as_mut();
3877
3878 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3879
3880 Ok(())
3881 }
3882 }
3883
3884 impl ::fidl_next::IntoNatural for Connector {
3885 type Natural = crate::natural::Connector;
3886 }
3887
3888 #[derive(Debug)]
3890 #[repr(C)]
3891 pub struct DirEntry {
3892 pub token: ::fidl_next::wire::fuchsia::EventPair,
3893 }
3894
3895 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
3896 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
3897
3898 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
3899
3900 impl ::fidl_next::Constrained for DirEntry {
3901 type Constraint = ();
3902
3903 fn validate(
3904 _: ::fidl_next::Slot<'_, Self>,
3905 _: Self::Constraint,
3906 ) -> Result<(), ::fidl_next::ValidationError> {
3907 Ok(())
3908 }
3909 }
3910
3911 unsafe impl ::fidl_next::Wire for DirEntry {
3912 type Narrowed<'de> = DirEntry;
3913
3914 #[inline]
3915 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3916 ::fidl_next::munge! {
3917 let Self {
3918 token,
3919
3920 } = &mut *out_;
3921 }
3922
3923 ::fidl_next::Wire::zero_padding(token);
3924 }
3925 }
3926
3927 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
3928 where
3929 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3930 ___D: ::fidl_next::fuchsia::HandleDecoder,
3931 {
3932 fn decode(
3933 slot_: ::fidl_next::Slot<'_, Self>,
3934 decoder_: &mut ___D,
3935 _: (),
3936 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3937 ::fidl_next::munge! {
3938 let Self {
3939 mut token,
3940
3941 } = slot_;
3942 }
3943
3944 let _field = token.as_mut();
3945
3946 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3947
3948 Ok(())
3949 }
3950 }
3951
3952 impl ::fidl_next::IntoNatural for DirEntry {
3953 type Natural = crate::natural::DirEntry;
3954 }
3955
3956 #[repr(transparent)]
3958 pub struct Capability<'de> {
3959 pub(crate) raw: ::fidl_next::wire::Union,
3960 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3961 }
3962
3963 impl<'de> Drop for Capability<'de> {
3964 fn drop(&mut self) {
3965 match self.raw.ordinal() {
3966 1 => {
3967 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
3968 }
3969
3970 2 => {
3971 let _ = unsafe {
3972 self.raw
3973 .get()
3974 .read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
3975 };
3976 }
3977
3978 3 => {
3979 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
3980 }
3981
3982 4 => {
3983 let _ =
3984 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
3985 }
3986
3987 5 => {
3988 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
3989 }
3990
3991 6 => {
3992 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
3993 }
3994
3995 7 => {
3996 let _ = unsafe {
3997 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3998 ::fidl_next_fuchsia_io::Directory,
3999 ::fidl_next::wire::fuchsia::Channel,
4000 >>()
4001 };
4002 }
4003
4004 8 => {
4005 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
4006 }
4007
4008 9 => {
4009 let _ = unsafe {
4010 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4011 crate::ConnectorRouter,
4012 ::fidl_next::wire::fuchsia::Channel,
4013 >>()
4014 };
4015 }
4016
4017 10 => {
4018 let _ = unsafe {
4019 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4020 crate::DictionaryRouter,
4021 ::fidl_next::wire::fuchsia::Channel,
4022 >>()
4023 };
4024 }
4025
4026 11 => {
4027 let _ = unsafe {
4028 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4029 crate::DirEntryRouter,
4030 ::fidl_next::wire::fuchsia::Channel,
4031 >>()
4032 };
4033 }
4034
4035 12 => {
4036 let _ = unsafe {
4037 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4038 crate::DataRouter,
4039 ::fidl_next::wire::fuchsia::Channel,
4040 >>()
4041 };
4042 }
4043
4044 13 => {
4045 let _ = unsafe {
4046 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4047 crate::DirConnectorRouter,
4048 ::fidl_next::wire::fuchsia::Channel,
4049 >>()
4050 };
4051 }
4052
4053 _ => (),
4054 }
4055 }
4056 }
4057
4058 impl ::fidl_next::Constrained for Capability<'_> {
4059 type Constraint = ();
4060
4061 fn validate(
4062 _: ::fidl_next::Slot<'_, Self>,
4063 _: Self::Constraint,
4064 ) -> Result<(), ::fidl_next::ValidationError> {
4065 Ok(())
4066 }
4067 }
4068
4069 unsafe impl ::fidl_next::Wire for Capability<'static> {
4070 type Narrowed<'de> = Capability<'de>;
4071
4072 #[inline]
4073 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4074 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4075 ::fidl_next::wire::Union::zero_padding(raw);
4076 }
4077 }
4078
4079 pub mod capability {
4080 pub enum Ref<'de> {
4081 Unit(&'de crate::wire::Unit),
4082
4083 Handle(&'de ::fidl_next::wire::fuchsia::NullableHandle),
4084
4085 Data(&'de crate::wire::Data<'de>),
4086
4087 Dictionary(&'de crate::wire::DictionaryRef),
4088
4089 Connector(&'de crate::wire::Connector),
4090
4091 DirConnector(&'de crate::wire::DirConnector),
4092
4093 Directory(
4094 &'de ::fidl_next::ClientEnd<
4095 ::fidl_next_fuchsia_io::Directory,
4096 ::fidl_next::wire::fuchsia::Channel,
4097 >,
4098 ),
4099
4100 DirEntry(&'de crate::wire::DirEntry),
4101
4102 ConnectorRouter(
4103 &'de ::fidl_next::ClientEnd<
4104 crate::ConnectorRouter,
4105 ::fidl_next::wire::fuchsia::Channel,
4106 >,
4107 ),
4108
4109 DictionaryRouter(
4110 &'de ::fidl_next::ClientEnd<
4111 crate::DictionaryRouter,
4112 ::fidl_next::wire::fuchsia::Channel,
4113 >,
4114 ),
4115
4116 DirEntryRouter(
4117 &'de ::fidl_next::ClientEnd<
4118 crate::DirEntryRouter,
4119 ::fidl_next::wire::fuchsia::Channel,
4120 >,
4121 ),
4122
4123 DataRouter(
4124 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
4125 ),
4126
4127 DirConnectorRouter(
4128 &'de ::fidl_next::ClientEnd<
4129 crate::DirConnectorRouter,
4130 ::fidl_next::wire::fuchsia::Channel,
4131 >,
4132 ),
4133
4134 UnknownOrdinal_(u64),
4135 }
4136
4137 pub enum Value<'de> {
4138 Unit(crate::wire::Unit),
4139
4140 Handle(::fidl_next::wire::fuchsia::NullableHandle),
4141
4142 Data(crate::wire::Data<'de>),
4143
4144 Dictionary(crate::wire::DictionaryRef),
4145
4146 Connector(crate::wire::Connector),
4147
4148 DirConnector(crate::wire::DirConnector),
4149
4150 Directory(
4151 ::fidl_next::ClientEnd<
4152 ::fidl_next_fuchsia_io::Directory,
4153 ::fidl_next::wire::fuchsia::Channel,
4154 >,
4155 ),
4156
4157 DirEntry(crate::wire::DirEntry),
4158
4159 ConnectorRouter(
4160 ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::wire::fuchsia::Channel>,
4161 ),
4162
4163 DictionaryRouter(
4164 ::fidl_next::ClientEnd<
4165 crate::DictionaryRouter,
4166 ::fidl_next::wire::fuchsia::Channel,
4167 >,
4168 ),
4169
4170 DirEntryRouter(
4171 ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::wire::fuchsia::Channel>,
4172 ),
4173
4174 DataRouter(
4175 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
4176 ),
4177
4178 DirConnectorRouter(
4179 ::fidl_next::ClientEnd<
4180 crate::DirConnectorRouter,
4181 ::fidl_next::wire::fuchsia::Channel,
4182 >,
4183 ),
4184
4185 UnknownOrdinal_(u64),
4186 }
4187 }
4188
4189 impl<'de> Capability<'de> {
4190 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
4191 match self.raw.ordinal() {
4192 1 => crate::wire::capability::Ref::Unit(unsafe {
4193 self.raw.get().deref_unchecked::<crate::wire::Unit>()
4194 }),
4195
4196 2 => crate::wire::capability::Ref::Handle(unsafe {
4197 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
4198 }),
4199
4200 3 => crate::wire::capability::Ref::Data(unsafe {
4201 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
4202 }),
4203
4204 4 => crate::wire::capability::Ref::Dictionary(unsafe {
4205 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
4206 }),
4207
4208 5 => crate::wire::capability::Ref::Connector(unsafe {
4209 self.raw.get().deref_unchecked::<crate::wire::Connector>()
4210 }),
4211
4212 6 => crate::wire::capability::Ref::DirConnector(unsafe {
4213 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
4214 }),
4215
4216 7 => crate::wire::capability::Ref::Directory(unsafe {
4217 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4218 ::fidl_next_fuchsia_io::Directory,
4219 ::fidl_next::wire::fuchsia::Channel,
4220 >>()
4221 }),
4222
4223 8 => crate::wire::capability::Ref::DirEntry(unsafe {
4224 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
4225 }),
4226
4227 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
4228 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4229 crate::ConnectorRouter,
4230 ::fidl_next::wire::fuchsia::Channel,
4231 >>()
4232 }),
4233
4234 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
4235 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4236 crate::DictionaryRouter,
4237 ::fidl_next::wire::fuchsia::Channel,
4238 >>()
4239 }),
4240
4241 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
4242 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4243 crate::DirEntryRouter,
4244 ::fidl_next::wire::fuchsia::Channel,
4245 >>()
4246 }),
4247
4248 12 => crate::wire::capability::Ref::DataRouter(unsafe {
4249 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4250 crate::DataRouter,
4251 ::fidl_next::wire::fuchsia::Channel,
4252 >>()
4253 }),
4254
4255 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
4256 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4257 crate::DirConnectorRouter,
4258 ::fidl_next::wire::fuchsia::Channel,
4259 >>()
4260 }),
4261
4262 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
4263 }
4264 }
4265
4266 pub fn into_inner(self) -> crate::wire::capability::Value<'de> {
4267 let this = ::core::mem::ManuallyDrop::new(self);
4268
4269 match this.raw.ordinal() {
4270 1 => crate::wire::capability::Value::Unit(unsafe {
4271 this.raw.get().read_unchecked::<crate::wire::Unit>()
4272 }),
4273
4274 2 => crate::wire::capability::Value::Handle(unsafe {
4275 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
4276 }),
4277
4278 3 => crate::wire::capability::Value::Data(unsafe {
4279 this.raw.get().read_unchecked::<crate::wire::Data<'de>>()
4280 }),
4281
4282 4 => crate::wire::capability::Value::Dictionary(unsafe {
4283 this.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
4284 }),
4285
4286 5 => crate::wire::capability::Value::Connector(unsafe {
4287 this.raw.get().read_unchecked::<crate::wire::Connector>()
4288 }),
4289
4290 6 => crate::wire::capability::Value::DirConnector(unsafe {
4291 this.raw.get().read_unchecked::<crate::wire::DirConnector>()
4292 }),
4293
4294 7 => crate::wire::capability::Value::Directory(unsafe {
4295 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4296 ::fidl_next_fuchsia_io::Directory,
4297 ::fidl_next::wire::fuchsia::Channel,
4298 >>()
4299 }),
4300
4301 8 => crate::wire::capability::Value::DirEntry(unsafe {
4302 this.raw.get().read_unchecked::<crate::wire::DirEntry>()
4303 }),
4304
4305 9 => crate::wire::capability::Value::ConnectorRouter(unsafe {
4306 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4307 crate::ConnectorRouter,
4308 ::fidl_next::wire::fuchsia::Channel,
4309 >>()
4310 }),
4311
4312 10 => crate::wire::capability::Value::DictionaryRouter(unsafe {
4313 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4314 crate::DictionaryRouter,
4315 ::fidl_next::wire::fuchsia::Channel,
4316 >>()
4317 }),
4318
4319 11 => crate::wire::capability::Value::DirEntryRouter(unsafe {
4320 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4321 crate::DirEntryRouter,
4322 ::fidl_next::wire::fuchsia::Channel,
4323 >>()
4324 }),
4325
4326 12 => crate::wire::capability::Value::DataRouter(unsafe {
4327 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4328 crate::DataRouter,
4329 ::fidl_next::wire::fuchsia::Channel,
4330 >>()
4331 }),
4332
4333 13 => crate::wire::capability::Value::DirConnectorRouter(unsafe {
4334 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4335 crate::DirConnectorRouter,
4336 ::fidl_next::wire::fuchsia::Channel,
4337 >>()
4338 }),
4339
4340 unknown => crate::wire::capability::Value::UnknownOrdinal_(unknown),
4341 }
4342 }
4343 }
4344
4345 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
4346 where
4347 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4348 ___D: ::fidl_next::Decoder<'de>,
4349 ___D: ::fidl_next::fuchsia::HandleDecoder,
4350 {
4351 fn decode(
4352 mut slot: ::fidl_next::Slot<'_, Self>,
4353 decoder: &mut ___D,
4354 _: (),
4355 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4356 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4357 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4358 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
4359 raw,
4360 decoder,
4361 (),
4362 )?,
4363
4364 2 => ::fidl_next::wire::Union::decode_as::<
4365 ___D,
4366 ::fidl_next::wire::fuchsia::NullableHandle,
4367 >(raw, decoder, ())?,
4368
4369 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
4370 raw,
4371 decoder,
4372 (),
4373 )?,
4374
4375 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DictionaryRef>(
4376 raw,
4377 decoder,
4378 (),
4379 )?,
4380
4381 5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Connector>(
4382 raw,
4383 decoder,
4384 (),
4385 )?,
4386
4387 6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirConnector>(
4388 raw,
4389 decoder,
4390 (),
4391 )?,
4392
4393 7 => ::fidl_next::wire::Union::decode_as::<
4394 ___D,
4395 ::fidl_next::ClientEnd<
4396 ::fidl_next_fuchsia_io::Directory,
4397 ::fidl_next::wire::fuchsia::Channel,
4398 >,
4399 >(raw, decoder, ())?,
4400
4401 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirEntry>(
4402 raw,
4403 decoder,
4404 (),
4405 )?,
4406
4407 9 => ::fidl_next::wire::Union::decode_as::<
4408 ___D,
4409 ::fidl_next::ClientEnd<
4410 crate::ConnectorRouter,
4411 ::fidl_next::wire::fuchsia::Channel,
4412 >,
4413 >(raw, decoder, ())?,
4414
4415 10 => ::fidl_next::wire::Union::decode_as::<
4416 ___D,
4417 ::fidl_next::ClientEnd<
4418 crate::DictionaryRouter,
4419 ::fidl_next::wire::fuchsia::Channel,
4420 >,
4421 >(raw, decoder, ())?,
4422
4423 11 => ::fidl_next::wire::Union::decode_as::<
4424 ___D,
4425 ::fidl_next::ClientEnd<
4426 crate::DirEntryRouter,
4427 ::fidl_next::wire::fuchsia::Channel,
4428 >,
4429 >(raw, decoder, ())?,
4430
4431 12 => ::fidl_next::wire::Union::decode_as::<
4432 ___D,
4433 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
4434 >(raw, decoder, ())?,
4435
4436 13 => ::fidl_next::wire::Union::decode_as::<
4437 ___D,
4438 ::fidl_next::ClientEnd<
4439 crate::DirConnectorRouter,
4440 ::fidl_next::wire::fuchsia::Channel,
4441 >,
4442 >(raw, decoder, ())?,
4443
4444 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4445 }
4446
4447 Ok(())
4448 }
4449 }
4450
4451 impl<'de> ::core::fmt::Debug for Capability<'de> {
4452 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4453 match self.raw.ordinal() {
4454 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
4455 2 => unsafe {
4456 self.raw
4457 .get()
4458 .deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
4459 .fmt(f)
4460 },
4461 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
4462 4 => unsafe {
4463 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
4464 },
4465 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
4466 6 => unsafe {
4467 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
4468 },
4469 7 => unsafe {
4470 self.raw
4471 .get()
4472 .deref_unchecked::<::fidl_next::ClientEnd<
4473 ::fidl_next_fuchsia_io::Directory,
4474 ::fidl_next::wire::fuchsia::Channel,
4475 >>()
4476 .fmt(f)
4477 },
4478 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
4479 9 => unsafe {
4480 self.raw
4481 .get()
4482 .deref_unchecked::<::fidl_next::ClientEnd<
4483 crate::ConnectorRouter,
4484 ::fidl_next::wire::fuchsia::Channel,
4485 >>()
4486 .fmt(f)
4487 },
4488 10 => unsafe {
4489 self.raw
4490 .get()
4491 .deref_unchecked::<::fidl_next::ClientEnd<
4492 crate::DictionaryRouter,
4493 ::fidl_next::wire::fuchsia::Channel,
4494 >>()
4495 .fmt(f)
4496 },
4497 11 => unsafe {
4498 self.raw
4499 .get()
4500 .deref_unchecked::<::fidl_next::ClientEnd<
4501 crate::DirEntryRouter,
4502 ::fidl_next::wire::fuchsia::Channel,
4503 >>()
4504 .fmt(f)
4505 },
4506 12 => unsafe {
4507 self.raw
4508 .get()
4509 .deref_unchecked::<::fidl_next::ClientEnd<
4510 crate::DataRouter,
4511 ::fidl_next::wire::fuchsia::Channel,
4512 >>()
4513 .fmt(f)
4514 },
4515 13 => unsafe {
4516 self.raw
4517 .get()
4518 .deref_unchecked::<::fidl_next::ClientEnd<
4519 crate::DirConnectorRouter,
4520 ::fidl_next::wire::fuchsia::Channel,
4521 >>()
4522 .fmt(f)
4523 },
4524 _ => unsafe { ::core::hint::unreachable_unchecked() },
4525 }
4526 }
4527 }
4528
4529 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
4530 type Natural = crate::natural::Capability;
4531 }
4532
4533 #[derive(Debug)]
4535 #[repr(C)]
4536 pub struct CapabilityStoreConnectorCreateRequest {
4537 pub id: ::fidl_next::wire::Uint64,
4538
4539 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
4540 }
4541
4542 static_assertions::const_assert_eq!(
4543 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
4544 16
4545 );
4546 static_assertions::const_assert_eq!(
4547 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
4548 8
4549 );
4550
4551 static_assertions::const_assert_eq!(
4552 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
4553 0
4554 );
4555
4556 static_assertions::const_assert_eq!(
4557 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
4558 8
4559 );
4560
4561 impl ::fidl_next::Constrained for CapabilityStoreConnectorCreateRequest {
4562 type Constraint = ();
4563
4564 fn validate(
4565 _: ::fidl_next::Slot<'_, Self>,
4566 _: Self::Constraint,
4567 ) -> Result<(), ::fidl_next::ValidationError> {
4568 Ok(())
4569 }
4570 }
4571
4572 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
4573 type Narrowed<'de> = CapabilityStoreConnectorCreateRequest;
4574
4575 #[inline]
4576 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4577 ::fidl_next::munge! {
4578 let Self {
4579 id,
4580 receiver,
4581
4582 } = &mut *out_;
4583 }
4584
4585 ::fidl_next::Wire::zero_padding(id);
4586
4587 ::fidl_next::Wire::zero_padding(receiver);
4588
4589 unsafe {
4590 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4591 }
4592 }
4593 }
4594
4595 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
4596 where
4597 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4598 ___D: ::fidl_next::fuchsia::HandleDecoder,
4599 {
4600 fn decode(
4601 slot_: ::fidl_next::Slot<'_, Self>,
4602 decoder_: &mut ___D,
4603 _: (),
4604 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4605 if slot_.as_bytes()[12..16] != [0u8; 4] {
4606 return Err(::fidl_next::DecodeError::InvalidPadding);
4607 }
4608
4609 ::fidl_next::munge! {
4610 let Self {
4611 mut id,
4612 mut receiver,
4613
4614 } = slot_;
4615 }
4616
4617 let _field = id.as_mut();
4618
4619 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4620
4621 let _field = receiver.as_mut();
4622
4623 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4624
4625 Ok(())
4626 }
4627 }
4628
4629 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
4630 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
4631 }
4632
4633 #[derive(Debug)]
4635 #[repr(C)]
4636 pub struct CapabilityStoreConnectorOpenRequest {
4637 pub id: ::fidl_next::wire::Uint64,
4638
4639 pub server_end: ::fidl_next::wire::fuchsia::Channel,
4640 }
4641
4642 static_assertions::const_assert_eq!(
4643 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
4644 16
4645 );
4646 static_assertions::const_assert_eq!(
4647 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
4648 8
4649 );
4650
4651 static_assertions::const_assert_eq!(
4652 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
4653 0
4654 );
4655
4656 static_assertions::const_assert_eq!(
4657 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
4658 8
4659 );
4660
4661 impl ::fidl_next::Constrained for CapabilityStoreConnectorOpenRequest {
4662 type Constraint = ();
4663
4664 fn validate(
4665 _: ::fidl_next::Slot<'_, Self>,
4666 _: Self::Constraint,
4667 ) -> Result<(), ::fidl_next::ValidationError> {
4668 Ok(())
4669 }
4670 }
4671
4672 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
4673 type Narrowed<'de> = CapabilityStoreConnectorOpenRequest;
4674
4675 #[inline]
4676 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4677 ::fidl_next::munge! {
4678 let Self {
4679 id,
4680 server_end,
4681
4682 } = &mut *out_;
4683 }
4684
4685 ::fidl_next::Wire::zero_padding(id);
4686
4687 ::fidl_next::Wire::zero_padding(server_end);
4688
4689 unsafe {
4690 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4691 }
4692 }
4693 }
4694
4695 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
4696 where
4697 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4698 ___D: ::fidl_next::fuchsia::HandleDecoder,
4699 {
4700 fn decode(
4701 slot_: ::fidl_next::Slot<'_, Self>,
4702 decoder_: &mut ___D,
4703 _: (),
4704 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4705 if slot_.as_bytes()[12..16] != [0u8; 4] {
4706 return Err(::fidl_next::DecodeError::InvalidPadding);
4707 }
4708
4709 ::fidl_next::munge! {
4710 let Self {
4711 mut id,
4712 mut server_end,
4713
4714 } = slot_;
4715 }
4716
4717 let _field = id.as_mut();
4718
4719 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4720
4721 let _field = server_end.as_mut();
4722
4723 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4724
4725 Ok(())
4726 }
4727 }
4728
4729 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
4730 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
4731 }
4732
4733 #[derive(Debug)]
4735 #[repr(C)]
4736 pub struct CapabilityStoreDirConnectorCreateRequest {
4737 pub id: ::fidl_next::wire::Uint64,
4738
4739 pub receiver:
4740 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
4741 }
4742
4743 static_assertions::const_assert_eq!(
4744 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
4745 16
4746 );
4747 static_assertions::const_assert_eq!(
4748 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
4749 8
4750 );
4751
4752 static_assertions::const_assert_eq!(
4753 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
4754 0
4755 );
4756
4757 static_assertions::const_assert_eq!(
4758 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
4759 8
4760 );
4761
4762 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorCreateRequest {
4763 type Constraint = ();
4764
4765 fn validate(
4766 _: ::fidl_next::Slot<'_, Self>,
4767 _: Self::Constraint,
4768 ) -> Result<(), ::fidl_next::ValidationError> {
4769 Ok(())
4770 }
4771 }
4772
4773 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
4774 type Narrowed<'de> = CapabilityStoreDirConnectorCreateRequest;
4775
4776 #[inline]
4777 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4778 ::fidl_next::munge! {
4779 let Self {
4780 id,
4781 receiver,
4782
4783 } = &mut *out_;
4784 }
4785
4786 ::fidl_next::Wire::zero_padding(id);
4787
4788 ::fidl_next::Wire::zero_padding(receiver);
4789
4790 unsafe {
4791 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4792 }
4793 }
4794 }
4795
4796 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
4797 where
4798 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4799 ___D: ::fidl_next::fuchsia::HandleDecoder,
4800 {
4801 fn decode(
4802 slot_: ::fidl_next::Slot<'_, Self>,
4803 decoder_: &mut ___D,
4804 _: (),
4805 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4806 if slot_.as_bytes()[12..16] != [0u8; 4] {
4807 return Err(::fidl_next::DecodeError::InvalidPadding);
4808 }
4809
4810 ::fidl_next::munge! {
4811 let Self {
4812 mut id,
4813 mut receiver,
4814
4815 } = slot_;
4816 }
4817
4818 let _field = id.as_mut();
4819
4820 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4821
4822 let _field = receiver.as_mut();
4823
4824 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4825
4826 Ok(())
4827 }
4828 }
4829
4830 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
4831 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
4832 }
4833
4834 #[derive(Debug)]
4836 #[repr(C)]
4837 pub struct CapabilityStoreDictionaryLegacyImportRequest {
4838 pub id: ::fidl_next::wire::Uint64,
4839
4840 pub client_end: ::fidl_next::wire::fuchsia::Channel,
4841 }
4842
4843 static_assertions::const_assert_eq!(
4844 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4845 16
4846 );
4847 static_assertions::const_assert_eq!(
4848 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4849 8
4850 );
4851
4852 static_assertions::const_assert_eq!(
4853 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
4854 0
4855 );
4856
4857 static_assertions::const_assert_eq!(
4858 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
4859 8
4860 );
4861
4862 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyImportRequest {
4863 type Constraint = ();
4864
4865 fn validate(
4866 _: ::fidl_next::Slot<'_, Self>,
4867 _: Self::Constraint,
4868 ) -> Result<(), ::fidl_next::ValidationError> {
4869 Ok(())
4870 }
4871 }
4872
4873 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
4874 type Narrowed<'de> = CapabilityStoreDictionaryLegacyImportRequest;
4875
4876 #[inline]
4877 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4878 ::fidl_next::munge! {
4879 let Self {
4880 id,
4881 client_end,
4882
4883 } = &mut *out_;
4884 }
4885
4886 ::fidl_next::Wire::zero_padding(id);
4887
4888 ::fidl_next::Wire::zero_padding(client_end);
4889
4890 unsafe {
4891 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4892 }
4893 }
4894 }
4895
4896 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
4897 where
4898 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4899 ___D: ::fidl_next::fuchsia::HandleDecoder,
4900 {
4901 fn decode(
4902 slot_: ::fidl_next::Slot<'_, Self>,
4903 decoder_: &mut ___D,
4904 _: (),
4905 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4906 if slot_.as_bytes()[12..16] != [0u8; 4] {
4907 return Err(::fidl_next::DecodeError::InvalidPadding);
4908 }
4909
4910 ::fidl_next::munge! {
4911 let Self {
4912 mut id,
4913 mut client_end,
4914
4915 } = slot_;
4916 }
4917
4918 let _field = id.as_mut();
4919
4920 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4921
4922 let _field = client_end.as_mut();
4923
4924 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
4925
4926 Ok(())
4927 }
4928 }
4929
4930 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
4931 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
4932 }
4933
4934 #[derive(Debug)]
4936 #[repr(C)]
4937 pub struct CapabilityStoreDictionaryLegacyExportRequest {
4938 pub id: ::fidl_next::wire::Uint64,
4939
4940 pub server_end: ::fidl_next::wire::fuchsia::Channel,
4941 }
4942
4943 static_assertions::const_assert_eq!(
4944 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4945 16
4946 );
4947 static_assertions::const_assert_eq!(
4948 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4949 8
4950 );
4951
4952 static_assertions::const_assert_eq!(
4953 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
4954 0
4955 );
4956
4957 static_assertions::const_assert_eq!(
4958 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
4959 8
4960 );
4961
4962 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyExportRequest {
4963 type Constraint = ();
4964
4965 fn validate(
4966 _: ::fidl_next::Slot<'_, Self>,
4967 _: Self::Constraint,
4968 ) -> Result<(), ::fidl_next::ValidationError> {
4969 Ok(())
4970 }
4971 }
4972
4973 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
4974 type Narrowed<'de> = CapabilityStoreDictionaryLegacyExportRequest;
4975
4976 #[inline]
4977 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4978 ::fidl_next::munge! {
4979 let Self {
4980 id,
4981 server_end,
4982
4983 } = &mut *out_;
4984 }
4985
4986 ::fidl_next::Wire::zero_padding(id);
4987
4988 ::fidl_next::Wire::zero_padding(server_end);
4989
4990 unsafe {
4991 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4992 }
4993 }
4994 }
4995
4996 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
4997 where
4998 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4999 ___D: ::fidl_next::fuchsia::HandleDecoder,
5000 {
5001 fn decode(
5002 slot_: ::fidl_next::Slot<'_, Self>,
5003 decoder_: &mut ___D,
5004 _: (),
5005 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5006 if slot_.as_bytes()[12..16] != [0u8; 4] {
5007 return Err(::fidl_next::DecodeError::InvalidPadding);
5008 }
5009
5010 ::fidl_next::munge! {
5011 let Self {
5012 mut id,
5013 mut server_end,
5014
5015 } = slot_;
5016 }
5017
5018 let _field = id.as_mut();
5019
5020 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5021
5022 let _field = server_end.as_mut();
5023
5024 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
5025
5026 Ok(())
5027 }
5028 }
5029
5030 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
5031 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
5032 }
5033
5034 #[derive(Debug)]
5036 #[repr(C)]
5037 pub struct CapabilityStoreDictionaryKeysRequest {
5038 pub id: ::fidl_next::wire::Uint64,
5039
5040 pub iterator: ::fidl_next::ServerEnd<
5041 crate::DictionaryKeysIterator,
5042 ::fidl_next::wire::fuchsia::Channel,
5043 >,
5044 }
5045
5046 static_assertions::const_assert_eq!(
5047 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
5048 16
5049 );
5050 static_assertions::const_assert_eq!(
5051 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
5052 8
5053 );
5054
5055 static_assertions::const_assert_eq!(
5056 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
5057 0
5058 );
5059
5060 static_assertions::const_assert_eq!(
5061 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
5062 8
5063 );
5064
5065 impl ::fidl_next::Constrained for CapabilityStoreDictionaryKeysRequest {
5066 type Constraint = ();
5067
5068 fn validate(
5069 _: ::fidl_next::Slot<'_, Self>,
5070 _: Self::Constraint,
5071 ) -> Result<(), ::fidl_next::ValidationError> {
5072 Ok(())
5073 }
5074 }
5075
5076 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
5077 type Narrowed<'de> = CapabilityStoreDictionaryKeysRequest;
5078
5079 #[inline]
5080 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5081 ::fidl_next::munge! {
5082 let Self {
5083 id,
5084 iterator,
5085
5086 } = &mut *out_;
5087 }
5088
5089 ::fidl_next::Wire::zero_padding(id);
5090
5091 ::fidl_next::Wire::zero_padding(iterator);
5092
5093 unsafe {
5094 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5095 }
5096 }
5097 }
5098
5099 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
5100 where
5101 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5102 ___D: ::fidl_next::fuchsia::HandleDecoder,
5103 {
5104 fn decode(
5105 slot_: ::fidl_next::Slot<'_, Self>,
5106 decoder_: &mut ___D,
5107 _: (),
5108 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5109 if slot_.as_bytes()[12..16] != [0u8; 4] {
5110 return Err(::fidl_next::DecodeError::InvalidPadding);
5111 }
5112
5113 ::fidl_next::munge! {
5114 let Self {
5115 mut id,
5116 mut iterator,
5117
5118 } = slot_;
5119 }
5120
5121 let _field = id.as_mut();
5122
5123 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5124
5125 let _field = iterator.as_mut();
5126
5127 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5128
5129 Ok(())
5130 }
5131 }
5132
5133 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
5134 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
5135 }
5136
5137 #[derive(Debug)]
5139 #[repr(C)]
5140 pub struct CapabilityStoreDictionaryEnumerateRequest {
5141 pub id: ::fidl_next::wire::Uint64,
5142
5143 pub iterator: ::fidl_next::ServerEnd<
5144 crate::DictionaryEnumerateIterator,
5145 ::fidl_next::wire::fuchsia::Channel,
5146 >,
5147 }
5148
5149 static_assertions::const_assert_eq!(
5150 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
5151 16
5152 );
5153 static_assertions::const_assert_eq!(
5154 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
5155 8
5156 );
5157
5158 static_assertions::const_assert_eq!(
5159 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
5160 0
5161 );
5162
5163 static_assertions::const_assert_eq!(
5164 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
5165 8
5166 );
5167
5168 impl ::fidl_next::Constrained for CapabilityStoreDictionaryEnumerateRequest {
5169 type Constraint = ();
5170
5171 fn validate(
5172 _: ::fidl_next::Slot<'_, Self>,
5173 _: Self::Constraint,
5174 ) -> Result<(), ::fidl_next::ValidationError> {
5175 Ok(())
5176 }
5177 }
5178
5179 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
5180 type Narrowed<'de> = CapabilityStoreDictionaryEnumerateRequest;
5181
5182 #[inline]
5183 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5184 ::fidl_next::munge! {
5185 let Self {
5186 id,
5187 iterator,
5188
5189 } = &mut *out_;
5190 }
5191
5192 ::fidl_next::Wire::zero_padding(id);
5193
5194 ::fidl_next::Wire::zero_padding(iterator);
5195
5196 unsafe {
5197 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5198 }
5199 }
5200 }
5201
5202 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
5203 where
5204 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5205 ___D: ::fidl_next::fuchsia::HandleDecoder,
5206 {
5207 fn decode(
5208 slot_: ::fidl_next::Slot<'_, Self>,
5209 decoder_: &mut ___D,
5210 _: (),
5211 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5212 if slot_.as_bytes()[12..16] != [0u8; 4] {
5213 return Err(::fidl_next::DecodeError::InvalidPadding);
5214 }
5215
5216 ::fidl_next::munge! {
5217 let Self {
5218 mut id,
5219 mut iterator,
5220
5221 } = slot_;
5222 }
5223
5224 let _field = id.as_mut();
5225
5226 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5227
5228 let _field = iterator.as_mut();
5229
5230 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5231
5232 Ok(())
5233 }
5234 }
5235
5236 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
5237 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
5238 }
5239
5240 #[derive(Debug)]
5242 #[repr(C)]
5243 pub struct CapabilityStoreDictionaryDrainRequest {
5244 pub id: ::fidl_next::wire::Uint64,
5245
5246 pub iterator: ::fidl_next::ServerEnd<
5247 crate::DictionaryDrainIterator,
5248 ::fidl_next::wire::fuchsia::OptionalChannel,
5249 >,
5250 }
5251
5252 static_assertions::const_assert_eq!(
5253 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
5254 16
5255 );
5256 static_assertions::const_assert_eq!(
5257 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
5258 8
5259 );
5260
5261 static_assertions::const_assert_eq!(
5262 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
5263 0
5264 );
5265
5266 static_assertions::const_assert_eq!(
5267 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
5268 8
5269 );
5270
5271 impl ::fidl_next::Constrained for CapabilityStoreDictionaryDrainRequest {
5272 type Constraint = ();
5273
5274 fn validate(
5275 _: ::fidl_next::Slot<'_, Self>,
5276 _: Self::Constraint,
5277 ) -> Result<(), ::fidl_next::ValidationError> {
5278 Ok(())
5279 }
5280 }
5281
5282 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
5283 type Narrowed<'de> = CapabilityStoreDictionaryDrainRequest;
5284
5285 #[inline]
5286 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5287 ::fidl_next::munge! {
5288 let Self {
5289 id,
5290 iterator,
5291
5292 } = &mut *out_;
5293 }
5294
5295 ::fidl_next::Wire::zero_padding(id);
5296
5297 ::fidl_next::Wire::zero_padding(iterator);
5298
5299 unsafe {
5300 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5301 }
5302 }
5303 }
5304
5305 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
5306 where
5307 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5308 ___D: ::fidl_next::fuchsia::HandleDecoder,
5309 {
5310 fn decode(
5311 slot_: ::fidl_next::Slot<'_, Self>,
5312 decoder_: &mut ___D,
5313 _: (),
5314 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5315 if slot_.as_bytes()[12..16] != [0u8; 4] {
5316 return Err(::fidl_next::DecodeError::InvalidPadding);
5317 }
5318
5319 ::fidl_next::munge! {
5320 let Self {
5321 mut id,
5322 mut iterator,
5323
5324 } = slot_;
5325 }
5326
5327 let _field = id.as_mut();
5328
5329 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5330
5331 let _field = iterator.as_mut();
5332
5333 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5334
5335 Ok(())
5336 }
5337 }
5338
5339 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
5340 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
5341 }
5342
5343 #[derive(Debug)]
5345 #[repr(C)]
5346 pub struct CapabilityStoreCreateServiceAggregateRequest<'de> {
5347 pub sources: ::fidl_next::wire::Vector<'de, crate::wire::AggregateSource<'de>>,
5348 }
5349
5350 static_assertions::const_assert_eq!(
5351 std::mem::size_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5352 16
5353 );
5354 static_assertions::const_assert_eq!(
5355 std::mem::align_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5356 8
5357 );
5358
5359 static_assertions::const_assert_eq!(
5360 std::mem::offset_of!(CapabilityStoreCreateServiceAggregateRequest<'_>, sources),
5361 0
5362 );
5363
5364 impl ::fidl_next::Constrained for CapabilityStoreCreateServiceAggregateRequest<'_> {
5365 type Constraint = ();
5366
5367 fn validate(
5368 _: ::fidl_next::Slot<'_, Self>,
5369 _: Self::Constraint,
5370 ) -> Result<(), ::fidl_next::ValidationError> {
5371 Ok(())
5372 }
5373 }
5374
5375 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateRequest<'static> {
5376 type Narrowed<'de> = CapabilityStoreCreateServiceAggregateRequest<'de>;
5377
5378 #[inline]
5379 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5380 ::fidl_next::munge! {
5381 let Self {
5382 sources,
5383
5384 } = &mut *out_;
5385 }
5386
5387 ::fidl_next::Wire::zero_padding(sources);
5388 }
5389 }
5390
5391 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5392 for CapabilityStoreCreateServiceAggregateRequest<'de>
5393 where
5394 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5395 ___D: ::fidl_next::Decoder<'de>,
5396 ___D: ::fidl_next::fuchsia::HandleDecoder,
5397 {
5398 fn decode(
5399 slot_: ::fidl_next::Slot<'_, Self>,
5400 decoder_: &mut ___D,
5401 _: (),
5402 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5403 ::fidl_next::munge! {
5404 let Self {
5405 mut sources,
5406
5407 } = slot_;
5408 }
5409
5410 let _field = sources.as_mut();
5411 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5412 ::fidl_next::Decode::decode(sources.as_mut(), decoder_, (4294967295, ()))?;
5413
5414 Ok(())
5415 }
5416 }
5417
5418 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateRequest<'de> {
5419 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateRequest;
5420 }
5421
5422 #[derive(Debug)]
5424 #[repr(C)]
5425 pub struct CapabilityStoreCreateServiceAggregateResponse {
5426 pub aggregate_dir_connector: crate::wire::DirConnector,
5427 }
5428
5429 static_assertions::const_assert_eq!(
5430 std::mem::size_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5431 4
5432 );
5433 static_assertions::const_assert_eq!(
5434 std::mem::align_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5435 4
5436 );
5437
5438 static_assertions::const_assert_eq!(
5439 std::mem::offset_of!(
5440 CapabilityStoreCreateServiceAggregateResponse,
5441 aggregate_dir_connector
5442 ),
5443 0
5444 );
5445
5446 impl ::fidl_next::Constrained for CapabilityStoreCreateServiceAggregateResponse {
5447 type Constraint = ();
5448
5449 fn validate(
5450 _: ::fidl_next::Slot<'_, Self>,
5451 _: Self::Constraint,
5452 ) -> Result<(), ::fidl_next::ValidationError> {
5453 Ok(())
5454 }
5455 }
5456
5457 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateResponse {
5458 type Narrowed<'de> = CapabilityStoreCreateServiceAggregateResponse;
5459
5460 #[inline]
5461 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5462 ::fidl_next::munge! {
5463 let Self {
5464 aggregate_dir_connector,
5465
5466 } = &mut *out_;
5467 }
5468
5469 ::fidl_next::Wire::zero_padding(aggregate_dir_connector);
5470 }
5471 }
5472
5473 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreCreateServiceAggregateResponse
5474 where
5475 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5476 ___D: ::fidl_next::fuchsia::HandleDecoder,
5477 {
5478 fn decode(
5479 slot_: ::fidl_next::Slot<'_, Self>,
5480 decoder_: &mut ___D,
5481 _: (),
5482 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5483 ::fidl_next::munge! {
5484 let Self {
5485 mut aggregate_dir_connector,
5486
5487 } = slot_;
5488 }
5489
5490 let _field = aggregate_dir_connector.as_mut();
5491
5492 ::fidl_next::Decode::decode(aggregate_dir_connector.as_mut(), decoder_, ())?;
5493
5494 Ok(())
5495 }
5496 }
5497
5498 impl ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateResponse {
5499 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateResponse;
5500 }
5501
5502 #[derive(Debug)]
5504 #[repr(C)]
5505 pub struct CapabilityStoreExportResponse<'de> {
5506 pub capability: crate::wire::Capability<'de>,
5507 }
5508
5509 static_assertions::const_assert_eq!(
5510 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
5511 16
5512 );
5513 static_assertions::const_assert_eq!(
5514 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
5515 8
5516 );
5517
5518 static_assertions::const_assert_eq!(
5519 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
5520 0
5521 );
5522
5523 impl ::fidl_next::Constrained for CapabilityStoreExportResponse<'_> {
5524 type Constraint = ();
5525
5526 fn validate(
5527 _: ::fidl_next::Slot<'_, Self>,
5528 _: Self::Constraint,
5529 ) -> Result<(), ::fidl_next::ValidationError> {
5530 Ok(())
5531 }
5532 }
5533
5534 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
5535 type Narrowed<'de> = CapabilityStoreExportResponse<'de>;
5536
5537 #[inline]
5538 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5539 ::fidl_next::munge! {
5540 let Self {
5541 capability,
5542
5543 } = &mut *out_;
5544 }
5545
5546 ::fidl_next::Wire::zero_padding(capability);
5547 }
5548 }
5549
5550 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'de>
5551 where
5552 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5553 ___D: ::fidl_next::Decoder<'de>,
5554 ___D: ::fidl_next::fuchsia::HandleDecoder,
5555 {
5556 fn decode(
5557 slot_: ::fidl_next::Slot<'_, Self>,
5558 decoder_: &mut ___D,
5559 _: (),
5560 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5561 ::fidl_next::munge! {
5562 let Self {
5563 mut capability,
5564
5565 } = slot_;
5566 }
5567
5568 let _field = capability.as_mut();
5569
5570 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5571
5572 Ok(())
5573 }
5574 }
5575
5576 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
5577 type Natural = crate::natural::CapabilityStoreExportResponse;
5578 }
5579
5580 #[derive(Debug)]
5582 #[repr(C)]
5583 pub struct CapabilityStoreImportRequest<'de> {
5584 pub id: ::fidl_next::wire::Uint64,
5585
5586 pub capability: crate::wire::Capability<'de>,
5587 }
5588
5589 static_assertions::const_assert_eq!(
5590 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
5591 24
5592 );
5593 static_assertions::const_assert_eq!(
5594 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
5595 8
5596 );
5597
5598 static_assertions::const_assert_eq!(
5599 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
5600 0
5601 );
5602
5603 static_assertions::const_assert_eq!(
5604 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
5605 8
5606 );
5607
5608 impl ::fidl_next::Constrained for CapabilityStoreImportRequest<'_> {
5609 type Constraint = ();
5610
5611 fn validate(
5612 _: ::fidl_next::Slot<'_, Self>,
5613 _: Self::Constraint,
5614 ) -> Result<(), ::fidl_next::ValidationError> {
5615 Ok(())
5616 }
5617 }
5618
5619 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
5620 type Narrowed<'de> = CapabilityStoreImportRequest<'de>;
5621
5622 #[inline]
5623 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5624 ::fidl_next::munge! {
5625 let Self {
5626 id,
5627 capability,
5628
5629 } = &mut *out_;
5630 }
5631
5632 ::fidl_next::Wire::zero_padding(id);
5633
5634 ::fidl_next::Wire::zero_padding(capability);
5635 }
5636 }
5637
5638 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'de>
5639 where
5640 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5641 ___D: ::fidl_next::Decoder<'de>,
5642 ___D: ::fidl_next::fuchsia::HandleDecoder,
5643 {
5644 fn decode(
5645 slot_: ::fidl_next::Slot<'_, Self>,
5646 decoder_: &mut ___D,
5647 _: (),
5648 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5649 ::fidl_next::munge! {
5650 let Self {
5651 mut id,
5652 mut capability,
5653
5654 } = slot_;
5655 }
5656
5657 let _field = id.as_mut();
5658
5659 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5660
5661 let _field = capability.as_mut();
5662
5663 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5664
5665 Ok(())
5666 }
5667 }
5668
5669 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
5670 type Natural = crate::natural::CapabilityStoreImportRequest;
5671 }
5672
5673 #[repr(C)]
5675 pub struct CapabilityStoreDirConnectorOpenRequest<'de> {
5676 pub(crate) table: ::fidl_next::wire::Table<'de>,
5677 }
5678
5679 impl<'de> Drop for CapabilityStoreDirConnectorOpenRequest<'de> {
5680 fn drop(&mut self) {
5681 let _ = self
5682 .table
5683 .get(1)
5684 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
5685
5686 let _ = self.table.get(2).map(|envelope| unsafe {
5687 envelope.read_unchecked::<::fidl_next::ServerEnd<
5688 ::fidl_next_fuchsia_io::Directory,
5689 ::fidl_next::wire::fuchsia::Channel,
5690 >>()
5691 });
5692
5693 let _ = self.table.get(3).map(|envelope| unsafe {
5694 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
5695 });
5696
5697 let _ = self.table.get(4).map(|envelope| unsafe {
5698 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
5699 });
5700 }
5701 }
5702
5703 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorOpenRequest<'_> {
5704 type Constraint = ();
5705
5706 fn validate(
5707 _: ::fidl_next::Slot<'_, Self>,
5708 _: Self::Constraint,
5709 ) -> Result<(), ::fidl_next::ValidationError> {
5710 Ok(())
5711 }
5712 }
5713
5714 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest<'static> {
5715 type Narrowed<'de> = CapabilityStoreDirConnectorOpenRequest<'de>;
5716
5717 #[inline]
5718 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5719 ::fidl_next::munge!(let Self { table } = out);
5720 ::fidl_next::wire::Table::zero_padding(table);
5721 }
5722 }
5723
5724 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest<'de>
5725 where
5726 ___D: ::fidl_next::Decoder<'de> + ?Sized,
5727 ___D: ::fidl_next::fuchsia::HandleDecoder,
5728 {
5729 fn decode(
5730 slot: ::fidl_next::Slot<'_, Self>,
5731 decoder: &mut ___D,
5732 _: (),
5733 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5734 ::fidl_next::munge!(let Self { table } = slot);
5735
5736 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5737 match ordinal {
5738 0 => unsafe { ::core::hint::unreachable_unchecked() },
5739
5740 1 => {
5741 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
5742 slot.as_mut(),
5743 decoder,
5744 (),
5745 )?;
5746
5747 Ok(())
5748 }
5749
5750 2 => {
5751 ::fidl_next::wire::Envelope::decode_as::<
5752 ___D,
5753 ::fidl_next::ServerEnd<
5754 ::fidl_next_fuchsia_io::Directory,
5755 ::fidl_next::wire::fuchsia::Channel,
5756 >,
5757 >(slot.as_mut(), decoder, ())?;
5758
5759 Ok(())
5760 }
5761
5762 3 => {
5763 ::fidl_next::wire::Envelope::decode_as::<
5764 ___D,
5765 ::fidl_next_fuchsia_io::wire::Flags,
5766 >(slot.as_mut(), decoder, ())?;
5767
5768 Ok(())
5769 }
5770
5771 4 => {
5772 ::fidl_next::wire::Envelope::decode_as::<
5773 ___D,
5774 ::fidl_next::wire::String<'de>,
5775 >(slot.as_mut(), decoder, 4095)?;
5776
5777 let value = unsafe {
5778 slot.deref_unchecked()
5779 .deref_unchecked::<::fidl_next::wire::String<'_>>()
5780 };
5781
5782 if value.len() > 4095 {
5783 return Err(::fidl_next::DecodeError::VectorTooLong {
5784 size: value.len() as u64,
5785 limit: 4095,
5786 });
5787 }
5788
5789 Ok(())
5790 }
5791
5792 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
5793 }
5794 })
5795 }
5796 }
5797
5798 impl<'de> CapabilityStoreDirConnectorOpenRequest<'de> {
5799 pub fn id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
5800 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5801 }
5802
5803 pub fn take_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
5804 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
5805 }
5806
5807 pub fn server_end(
5808 &self,
5809 ) -> ::core::option::Option<
5810 &::fidl_next::ServerEnd<
5811 ::fidl_next_fuchsia_io::Directory,
5812 ::fidl_next::wire::fuchsia::Channel,
5813 >,
5814 > {
5815 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5816 }
5817
5818 pub fn take_server_end(
5819 &mut self,
5820 ) -> ::core::option::Option<
5821 ::fidl_next::ServerEnd<
5822 ::fidl_next_fuchsia_io::Directory,
5823 ::fidl_next::wire::fuchsia::Channel,
5824 >,
5825 > {
5826 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
5827 }
5828
5829 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
5830 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
5831 }
5832
5833 pub fn take_flags(
5834 &mut self,
5835 ) -> ::core::option::Option<::fidl_next_fuchsia_io::wire::Flags> {
5836 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
5837 }
5838
5839 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
5840 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
5841 }
5842
5843 pub fn take_path(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
5844 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
5845 }
5846 }
5847
5848 impl<'de> ::core::fmt::Debug for CapabilityStoreDirConnectorOpenRequest<'de> {
5849 fn fmt(
5850 &self,
5851 f: &mut ::core::fmt::Formatter<'_>,
5852 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5853 f.debug_struct("CapabilityStoreDirConnectorOpenRequest")
5854 .field("id", &self.id())
5855 .field("server_end", &self.server_end())
5856 .field("flags", &self.flags())
5857 .field("path", &self.path())
5858 .finish()
5859 }
5860 }
5861
5862 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest<'de> {
5863 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
5864 }
5865
5866 #[derive(Debug)]
5868 #[repr(C)]
5869 pub struct InstanceToken {
5870 pub token: ::fidl_next::wire::fuchsia::EventPair,
5871 }
5872
5873 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
5874 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
5875
5876 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
5877
5878 impl ::fidl_next::Constrained for InstanceToken {
5879 type Constraint = ();
5880
5881 fn validate(
5882 _: ::fidl_next::Slot<'_, Self>,
5883 _: Self::Constraint,
5884 ) -> Result<(), ::fidl_next::ValidationError> {
5885 Ok(())
5886 }
5887 }
5888
5889 unsafe impl ::fidl_next::Wire for InstanceToken {
5890 type Narrowed<'de> = InstanceToken;
5891
5892 #[inline]
5893 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5894 ::fidl_next::munge! {
5895 let Self {
5896 token,
5897
5898 } = &mut *out_;
5899 }
5900
5901 ::fidl_next::Wire::zero_padding(token);
5902 }
5903 }
5904
5905 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
5906 where
5907 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5908 ___D: ::fidl_next::fuchsia::HandleDecoder,
5909 {
5910 fn decode(
5911 slot_: ::fidl_next::Slot<'_, Self>,
5912 decoder_: &mut ___D,
5913 _: (),
5914 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5915 ::fidl_next::munge! {
5916 let Self {
5917 mut token,
5918
5919 } = slot_;
5920 }
5921
5922 let _field = token.as_mut();
5923
5924 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
5925
5926 Ok(())
5927 }
5928 }
5929
5930 impl ::fidl_next::IntoNatural for InstanceToken {
5931 type Natural = crate::natural::InstanceToken;
5932 }
5933
5934 #[repr(C)]
5936 pub struct RouteRequest<'de> {
5937 pub(crate) table: ::fidl_next::wire::Table<'de>,
5938 }
5939
5940 impl<'de> Drop for RouteRequest<'de> {
5941 fn drop(&mut self) {
5942 let _ = self
5943 .table
5944 .get(1)
5945 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
5946 }
5947 }
5948
5949 impl ::fidl_next::Constrained for RouteRequest<'_> {
5950 type Constraint = ();
5951
5952 fn validate(
5953 _: ::fidl_next::Slot<'_, Self>,
5954 _: Self::Constraint,
5955 ) -> Result<(), ::fidl_next::ValidationError> {
5956 Ok(())
5957 }
5958 }
5959
5960 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
5961 type Narrowed<'de> = RouteRequest<'de>;
5962
5963 #[inline]
5964 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5965 ::fidl_next::munge!(let Self { table } = out);
5966 ::fidl_next::wire::Table::zero_padding(table);
5967 }
5968 }
5969
5970 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RouteRequest<'de>
5971 where
5972 ___D: ::fidl_next::Decoder<'de> + ?Sized,
5973 ___D: ::fidl_next::fuchsia::HandleDecoder,
5974 {
5975 fn decode(
5976 slot: ::fidl_next::Slot<'_, Self>,
5977 decoder: &mut ___D,
5978 _: (),
5979 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5980 ::fidl_next::munge!(let Self { table } = slot);
5981
5982 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5983 match ordinal {
5984 0 => unsafe { ::core::hint::unreachable_unchecked() },
5985
5986 1 => {
5987 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::InstanceToken>(
5988 slot.as_mut(),
5989 decoder,
5990 (),
5991 )?;
5992
5993 Ok(())
5994 }
5995
5996 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
5997 }
5998 })
5999 }
6000 }
6001
6002 impl<'de> RouteRequest<'de> {
6003 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
6004 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
6005 }
6006
6007 pub fn take_requesting(&mut self) -> ::core::option::Option<crate::wire::InstanceToken> {
6008 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
6009 }
6010 }
6011
6012 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
6013 fn fmt(
6014 &self,
6015 f: &mut ::core::fmt::Formatter<'_>,
6016 ) -> ::core::result::Result<(), ::core::fmt::Error> {
6017 f.debug_struct("RouteRequest").field("requesting", &self.requesting()).finish()
6018 }
6019 }
6020
6021 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
6022 type Natural = crate::natural::RouteRequest;
6023 }
6024
6025 #[repr(transparent)]
6027 pub struct ConnectorRouterRouteResponse {
6028 pub(crate) raw: ::fidl_next::wire::Union,
6029 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6030 }
6031
6032 impl Drop for ConnectorRouterRouteResponse {
6033 fn drop(&mut self) {
6034 match self.raw.ordinal() {
6035 1 => {
6036 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
6037 }
6038
6039 2 => {
6040 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6041 }
6042
6043 _ => unsafe { ::core::hint::unreachable_unchecked() },
6044 }
6045 }
6046 }
6047
6048 impl ::fidl_next::Constrained for ConnectorRouterRouteResponse {
6049 type Constraint = ();
6050
6051 fn validate(
6052 _: ::fidl_next::Slot<'_, Self>,
6053 _: Self::Constraint,
6054 ) -> Result<(), ::fidl_next::ValidationError> {
6055 Ok(())
6056 }
6057 }
6058
6059 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
6060 type Narrowed<'de> = ConnectorRouterRouteResponse;
6061
6062 #[inline]
6063 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6064 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6065 ::fidl_next::wire::Union::zero_padding(raw);
6066 }
6067 }
6068
6069 pub mod connector_router_route_response {
6070 pub enum Ref<'de> {
6071 Connector(&'de crate::wire::Connector),
6072
6073 Unavailable(&'de crate::wire::Unit),
6074 }
6075
6076 pub enum Value {
6077 Connector(crate::wire::Connector),
6078
6079 Unavailable(crate::wire::Unit),
6080 }
6081 }
6082
6083 impl ConnectorRouterRouteResponse {
6084 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
6085 match self.raw.ordinal() {
6086 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
6087 self.raw.get().deref_unchecked::<crate::wire::Connector>()
6088 }),
6089
6090 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
6091 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6092 }),
6093
6094 _ => unsafe { ::core::hint::unreachable_unchecked() },
6095 }
6096 }
6097
6098 pub fn into_inner(self) -> crate::wire::connector_router_route_response::Value {
6099 let this = ::core::mem::ManuallyDrop::new(self);
6100
6101 match this.raw.ordinal() {
6102 1 => crate::wire::connector_router_route_response::Value::Connector(unsafe {
6103 this.raw.get().read_unchecked::<crate::wire::Connector>()
6104 }),
6105
6106 2 => crate::wire::connector_router_route_response::Value::Unavailable(unsafe {
6107 this.raw.get().read_unchecked::<crate::wire::Unit>()
6108 }),
6109
6110 _ => unsafe { ::core::hint::unreachable_unchecked() },
6111 }
6112 }
6113 }
6114
6115 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
6116 where
6117 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6118 ___D: ::fidl_next::fuchsia::HandleDecoder,
6119 {
6120 fn decode(
6121 mut slot: ::fidl_next::Slot<'_, Self>,
6122 decoder: &mut ___D,
6123 _: (),
6124 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6125 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6126 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6127 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Connector>(
6128 raw,
6129 decoder,
6130 (),
6131 )?,
6132
6133 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6134 raw,
6135 decoder,
6136 (),
6137 )?,
6138
6139 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6140 }
6141
6142 Ok(())
6143 }
6144 }
6145
6146 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
6147 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6148 match self.raw.ordinal() {
6149 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
6150 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6151 _ => unsafe { ::core::hint::unreachable_unchecked() },
6152 }
6153 }
6154 }
6155
6156 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
6157 type Natural = crate::natural::ConnectorRouterRouteResponse;
6158 }
6159
6160 #[repr(transparent)]
6162 pub struct DataRouterRouteResponse<'de> {
6163 pub(crate) raw: ::fidl_next::wire::Union,
6164 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6165 }
6166
6167 impl<'de> Drop for DataRouterRouteResponse<'de> {
6168 fn drop(&mut self) {
6169 match self.raw.ordinal() {
6170 1 => {
6171 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
6172 }
6173
6174 2 => {
6175 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6176 }
6177
6178 _ => unsafe { ::core::hint::unreachable_unchecked() },
6179 }
6180 }
6181 }
6182
6183 impl ::fidl_next::Constrained for DataRouterRouteResponse<'_> {
6184 type Constraint = ();
6185
6186 fn validate(
6187 _: ::fidl_next::Slot<'_, Self>,
6188 _: Self::Constraint,
6189 ) -> Result<(), ::fidl_next::ValidationError> {
6190 Ok(())
6191 }
6192 }
6193
6194 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
6195 type Narrowed<'de> = DataRouterRouteResponse<'de>;
6196
6197 #[inline]
6198 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6199 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6200 ::fidl_next::wire::Union::zero_padding(raw);
6201 }
6202 }
6203
6204 pub mod data_router_route_response {
6205 pub enum Ref<'de> {
6206 Data(&'de crate::wire::Data<'de>),
6207
6208 Unavailable(&'de crate::wire::Unit),
6209 }
6210
6211 pub enum Value<'de> {
6212 Data(crate::wire::Data<'de>),
6213
6214 Unavailable(crate::wire::Unit),
6215 }
6216 }
6217
6218 impl<'de> DataRouterRouteResponse<'de> {
6219 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
6220 match self.raw.ordinal() {
6221 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
6222 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
6223 }),
6224
6225 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
6226 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6227 }),
6228
6229 _ => unsafe { ::core::hint::unreachable_unchecked() },
6230 }
6231 }
6232
6233 pub fn into_inner(self) -> crate::wire::data_router_route_response::Value<'de> {
6234 let this = ::core::mem::ManuallyDrop::new(self);
6235
6236 match this.raw.ordinal() {
6237 1 => crate::wire::data_router_route_response::Value::Data(unsafe {
6238 this.raw.get().read_unchecked::<crate::wire::Data<'de>>()
6239 }),
6240
6241 2 => crate::wire::data_router_route_response::Value::Unavailable(unsafe {
6242 this.raw.get().read_unchecked::<crate::wire::Unit>()
6243 }),
6244
6245 _ => unsafe { ::core::hint::unreachable_unchecked() },
6246 }
6247 }
6248 }
6249
6250 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'de>
6251 where
6252 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6253 ___D: ::fidl_next::Decoder<'de>,
6254 ___D: ::fidl_next::fuchsia::HandleDecoder,
6255 {
6256 fn decode(
6257 mut slot: ::fidl_next::Slot<'_, Self>,
6258 decoder: &mut ___D,
6259 _: (),
6260 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6261 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6262 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6263 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
6264 raw,
6265 decoder,
6266 (),
6267 )?,
6268
6269 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
6270 raw,
6271 decoder,
6272 (),
6273 )?,
6274
6275 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6276 }
6277
6278 Ok(())
6279 }
6280 }
6281
6282 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
6283 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6284 match self.raw.ordinal() {
6285 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
6286 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6287 _ => unsafe { ::core::hint::unreachable_unchecked() },
6288 }
6289 }
6290 }
6291
6292 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
6293 type Natural = crate::natural::DataRouterRouteResponse;
6294 }
6295
6296 #[derive(Debug)]
6298 #[repr(C)]
6299 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
6300 pub items: ::fidl_next::wire::Vector<'de, crate::wire::DictionaryItem<'de>>,
6301
6302 pub end_id: ::fidl_next::wire::Uint64,
6303 }
6304
6305 static_assertions::const_assert_eq!(
6306 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
6307 24
6308 );
6309 static_assertions::const_assert_eq!(
6310 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
6311 8
6312 );
6313
6314 static_assertions::const_assert_eq!(
6315 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
6316 0
6317 );
6318
6319 static_assertions::const_assert_eq!(
6320 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
6321 16
6322 );
6323
6324 impl ::fidl_next::Constrained for DictionaryDrainIteratorGetNextResponse<'_> {
6325 type Constraint = ();
6326
6327 fn validate(
6328 _: ::fidl_next::Slot<'_, Self>,
6329 _: Self::Constraint,
6330 ) -> Result<(), ::fidl_next::ValidationError> {
6331 Ok(())
6332 }
6333 }
6334
6335 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
6336 type Narrowed<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
6337
6338 #[inline]
6339 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6340 ::fidl_next::munge! {
6341 let Self {
6342 items,
6343 end_id,
6344
6345 } = &mut *out_;
6346 }
6347
6348 ::fidl_next::Wire::zero_padding(items);
6349
6350 ::fidl_next::Wire::zero_padding(end_id);
6351 }
6352 }
6353
6354 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'de>
6355 where
6356 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6357 ___D: ::fidl_next::Decoder<'de>,
6358 ___D: ::fidl_next::fuchsia::HandleDecoder,
6359 {
6360 fn decode(
6361 slot_: ::fidl_next::Slot<'_, Self>,
6362 decoder_: &mut ___D,
6363 _: (),
6364 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6365 ::fidl_next::munge! {
6366 let Self {
6367 mut items,
6368 mut end_id,
6369
6370 } = slot_;
6371 }
6372
6373 let _field = items.as_mut();
6374 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6375 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
6376
6377 let items = unsafe { items.deref_unchecked() };
6378
6379 if items.len() > 128 {
6380 return Err(::fidl_next::DecodeError::VectorTooLong {
6381 size: items.len() as u64,
6382 limit: 128,
6383 });
6384 }
6385
6386 let _field = end_id.as_mut();
6387
6388 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6389
6390 Ok(())
6391 }
6392 }
6393
6394 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
6395 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
6396 }
6397
6398 #[derive(Debug)]
6400 #[repr(C)]
6401 pub struct DictionaryOptionalItem<'de> {
6402 pub key: ::fidl_next::wire::String<'de>,
6403
6404 pub value: ::fidl_next::wire::Box<'de, crate::wire::WrappedCapabilityId>,
6405 }
6406
6407 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
6408 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
6409
6410 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
6411
6412 static_assertions::const_assert_eq!(
6413 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
6414 16
6415 );
6416
6417 impl ::fidl_next::Constrained for DictionaryOptionalItem<'_> {
6418 type Constraint = ();
6419
6420 fn validate(
6421 _: ::fidl_next::Slot<'_, Self>,
6422 _: Self::Constraint,
6423 ) -> Result<(), ::fidl_next::ValidationError> {
6424 Ok(())
6425 }
6426 }
6427
6428 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
6429 type Narrowed<'de> = DictionaryOptionalItem<'de>;
6430
6431 #[inline]
6432 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6433 ::fidl_next::munge! {
6434 let Self {
6435 key,
6436 value,
6437
6438 } = &mut *out_;
6439 }
6440
6441 ::fidl_next::Wire::zero_padding(key);
6442
6443 ::fidl_next::Wire::zero_padding(value);
6444 }
6445 }
6446
6447 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'de>
6448 where
6449 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6450 ___D: ::fidl_next::Decoder<'de>,
6451 ___D: ::fidl_next::fuchsia::HandleDecoder,
6452 {
6453 fn decode(
6454 slot_: ::fidl_next::Slot<'_, Self>,
6455 decoder_: &mut ___D,
6456 _: (),
6457 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6458 ::fidl_next::munge! {
6459 let Self {
6460 mut key,
6461 mut value,
6462
6463 } = slot_;
6464 }
6465
6466 let _field = key.as_mut();
6467 ::fidl_next::Constrained::validate(_field, 255)?;
6468 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
6469
6470 let key = unsafe { key.deref_unchecked() };
6471
6472 if key.len() > 255 {
6473 return Err(::fidl_next::DecodeError::VectorTooLong {
6474 size: key.len() as u64,
6475 limit: 255,
6476 });
6477 }
6478
6479 let _field = value.as_mut();
6480
6481 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
6482
6483 Ok(())
6484 }
6485 }
6486
6487 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
6488 type Natural = crate::natural::DictionaryOptionalItem;
6489 }
6490
6491 #[derive(Debug)]
6493 #[repr(C)]
6494 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
6495 pub items: ::fidl_next::wire::Vector<'de, crate::wire::DictionaryOptionalItem<'de>>,
6496
6497 pub end_id: ::fidl_next::wire::Uint64,
6498 }
6499
6500 static_assertions::const_assert_eq!(
6501 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6502 24
6503 );
6504 static_assertions::const_assert_eq!(
6505 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6506 8
6507 );
6508
6509 static_assertions::const_assert_eq!(
6510 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
6511 0
6512 );
6513
6514 static_assertions::const_assert_eq!(
6515 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
6516 16
6517 );
6518
6519 impl ::fidl_next::Constrained for DictionaryEnumerateIteratorGetNextResponse<'_> {
6520 type Constraint = ();
6521
6522 fn validate(
6523 _: ::fidl_next::Slot<'_, Self>,
6524 _: Self::Constraint,
6525 ) -> Result<(), ::fidl_next::ValidationError> {
6526 Ok(())
6527 }
6528 }
6529
6530 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
6531 type Narrowed<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
6532
6533 #[inline]
6534 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6535 ::fidl_next::munge! {
6536 let Self {
6537 items,
6538 end_id,
6539
6540 } = &mut *out_;
6541 }
6542
6543 ::fidl_next::Wire::zero_padding(items);
6544
6545 ::fidl_next::Wire::zero_padding(end_id);
6546 }
6547 }
6548
6549 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'de>
6550 where
6551 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6552 ___D: ::fidl_next::Decoder<'de>,
6553 ___D: ::fidl_next::fuchsia::HandleDecoder,
6554 {
6555 fn decode(
6556 slot_: ::fidl_next::Slot<'_, Self>,
6557 decoder_: &mut ___D,
6558 _: (),
6559 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6560 ::fidl_next::munge! {
6561 let Self {
6562 mut items,
6563 mut end_id,
6564
6565 } = slot_;
6566 }
6567
6568 let _field = items.as_mut();
6569 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6570 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
6571
6572 let items = unsafe { items.deref_unchecked() };
6573
6574 if items.len() > 128 {
6575 return Err(::fidl_next::DecodeError::VectorTooLong {
6576 size: items.len() as u64,
6577 limit: 128,
6578 });
6579 }
6580
6581 let _field = end_id.as_mut();
6582
6583 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6584
6585 Ok(())
6586 }
6587 }
6588
6589 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
6590 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
6591 }
6592
6593 #[derive(Debug)]
6595 #[repr(C)]
6596 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
6597 pub keys: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
6598 }
6599
6600 static_assertions::const_assert_eq!(
6601 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6602 16
6603 );
6604 static_assertions::const_assert_eq!(
6605 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6606 8
6607 );
6608
6609 static_assertions::const_assert_eq!(
6610 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
6611 0
6612 );
6613
6614 impl ::fidl_next::Constrained for DictionaryKeysIteratorGetNextResponse<'_> {
6615 type Constraint = ();
6616
6617 fn validate(
6618 _: ::fidl_next::Slot<'_, Self>,
6619 _: Self::Constraint,
6620 ) -> Result<(), ::fidl_next::ValidationError> {
6621 Ok(())
6622 }
6623 }
6624
6625 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
6626 type Narrowed<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
6627
6628 #[inline]
6629 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6630 ::fidl_next::munge! {
6631 let Self {
6632 keys,
6633
6634 } = &mut *out_;
6635 }
6636
6637 ::fidl_next::Wire::zero_padding(keys);
6638 }
6639 }
6640
6641 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'de>
6642 where
6643 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6644 ___D: ::fidl_next::Decoder<'de>,
6645 ___D: ::fidl_next::fuchsia::HandleDecoder,
6646 {
6647 fn decode(
6648 slot_: ::fidl_next::Slot<'_, Self>,
6649 decoder_: &mut ___D,
6650 _: (),
6651 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6652 ::fidl_next::munge! {
6653 let Self {
6654 mut keys,
6655
6656 } = slot_;
6657 }
6658
6659 let _field = keys.as_mut();
6660 ::fidl_next::Constrained::validate(_field, (128, 255))?;
6661 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
6662
6663 let keys = unsafe { keys.deref_unchecked() };
6664
6665 if keys.len() > 128 {
6666 return Err(::fidl_next::DecodeError::VectorTooLong {
6667 size: keys.len() as u64,
6668 limit: 128,
6669 });
6670 }
6671
6672 Ok(())
6673 }
6674 }
6675
6676 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
6677 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
6678 }
6679
6680 #[repr(transparent)]
6682 pub struct DictionaryRouterRouteResponse {
6683 pub(crate) raw: ::fidl_next::wire::Union,
6684 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6685 }
6686
6687 impl Drop for DictionaryRouterRouteResponse {
6688 fn drop(&mut self) {
6689 match self.raw.ordinal() {
6690 1 => {
6691 let _ =
6692 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
6693 }
6694
6695 2 => {
6696 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6697 }
6698
6699 _ => unsafe { ::core::hint::unreachable_unchecked() },
6700 }
6701 }
6702 }
6703
6704 impl ::fidl_next::Constrained for DictionaryRouterRouteResponse {
6705 type Constraint = ();
6706
6707 fn validate(
6708 _: ::fidl_next::Slot<'_, Self>,
6709 _: Self::Constraint,
6710 ) -> Result<(), ::fidl_next::ValidationError> {
6711 Ok(())
6712 }
6713 }
6714
6715 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
6716 type Narrowed<'de> = DictionaryRouterRouteResponse;
6717
6718 #[inline]
6719 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6720 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6721 ::fidl_next::wire::Union::zero_padding(raw);
6722 }
6723 }
6724
6725 pub mod dictionary_router_route_response {
6726 pub enum Ref<'de> {
6727 Dictionary(&'de crate::wire::DictionaryRef),
6728
6729 Unavailable(&'de crate::wire::Unit),
6730 }
6731
6732 pub enum Value {
6733 Dictionary(crate::wire::DictionaryRef),
6734
6735 Unavailable(crate::wire::Unit),
6736 }
6737 }
6738
6739 impl DictionaryRouterRouteResponse {
6740 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
6741 match self.raw.ordinal() {
6742 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
6743 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
6744 }),
6745
6746 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
6747 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6748 }),
6749
6750 _ => unsafe { ::core::hint::unreachable_unchecked() },
6751 }
6752 }
6753
6754 pub fn into_inner(self) -> crate::wire::dictionary_router_route_response::Value {
6755 let this = ::core::mem::ManuallyDrop::new(self);
6756
6757 match this.raw.ordinal() {
6758 1 => crate::wire::dictionary_router_route_response::Value::Dictionary(unsafe {
6759 this.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
6760 }),
6761
6762 2 => crate::wire::dictionary_router_route_response::Value::Unavailable(unsafe {
6763 this.raw.get().read_unchecked::<crate::wire::Unit>()
6764 }),
6765
6766 _ => unsafe { ::core::hint::unreachable_unchecked() },
6767 }
6768 }
6769 }
6770
6771 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
6772 where
6773 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6774 ___D: ::fidl_next::fuchsia::HandleDecoder,
6775 {
6776 fn decode(
6777 mut slot: ::fidl_next::Slot<'_, Self>,
6778 decoder: &mut ___D,
6779 _: (),
6780 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6781 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6782 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6783 1 => {
6784 ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DictionaryRef>(
6785 raw,
6786 decoder,
6787 (),
6788 )?
6789 }
6790
6791 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6792 raw,
6793 decoder,
6794 (),
6795 )?,
6796
6797 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6798 }
6799
6800 Ok(())
6801 }
6802 }
6803
6804 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
6805 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6806 match self.raw.ordinal() {
6807 1 => unsafe {
6808 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
6809 },
6810 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6811 _ => unsafe { ::core::hint::unreachable_unchecked() },
6812 }
6813 }
6814 }
6815
6816 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
6817 type Natural = crate::natural::DictionaryRouterRouteResponse;
6818 }
6819
6820 #[repr(transparent)]
6822 pub struct DirConnectorRouterRouteResponse {
6823 pub(crate) raw: ::fidl_next::wire::Union,
6824 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6825 }
6826
6827 impl Drop for DirConnectorRouterRouteResponse {
6828 fn drop(&mut self) {
6829 match self.raw.ordinal() {
6830 1 => {
6831 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
6832 }
6833
6834 2 => {
6835 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6836 }
6837
6838 _ => unsafe { ::core::hint::unreachable_unchecked() },
6839 }
6840 }
6841 }
6842
6843 impl ::fidl_next::Constrained for DirConnectorRouterRouteResponse {
6844 type Constraint = ();
6845
6846 fn validate(
6847 _: ::fidl_next::Slot<'_, Self>,
6848 _: Self::Constraint,
6849 ) -> Result<(), ::fidl_next::ValidationError> {
6850 Ok(())
6851 }
6852 }
6853
6854 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
6855 type Narrowed<'de> = DirConnectorRouterRouteResponse;
6856
6857 #[inline]
6858 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6859 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6860 ::fidl_next::wire::Union::zero_padding(raw);
6861 }
6862 }
6863
6864 pub mod dir_connector_router_route_response {
6865 pub enum Ref<'de> {
6866 DirConnector(&'de crate::wire::DirConnector),
6867
6868 Unavailable(&'de crate::wire::Unit),
6869 }
6870
6871 pub enum Value {
6872 DirConnector(crate::wire::DirConnector),
6873
6874 Unavailable(crate::wire::Unit),
6875 }
6876 }
6877
6878 impl DirConnectorRouterRouteResponse {
6879 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
6880 match self.raw.ordinal() {
6881 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
6882 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
6883 }),
6884
6885 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
6886 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6887 }),
6888
6889 _ => unsafe { ::core::hint::unreachable_unchecked() },
6890 }
6891 }
6892
6893 pub fn into_inner(self) -> crate::wire::dir_connector_router_route_response::Value {
6894 let this = ::core::mem::ManuallyDrop::new(self);
6895
6896 match this.raw.ordinal() {
6897 1 => {
6898 crate::wire::dir_connector_router_route_response::Value::DirConnector(unsafe {
6899 this.raw.get().read_unchecked::<crate::wire::DirConnector>()
6900 })
6901 }
6902
6903 2 => crate::wire::dir_connector_router_route_response::Value::Unavailable(unsafe {
6904 this.raw.get().read_unchecked::<crate::wire::Unit>()
6905 }),
6906
6907 _ => unsafe { ::core::hint::unreachable_unchecked() },
6908 }
6909 }
6910 }
6911
6912 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
6913 where
6914 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6915 ___D: ::fidl_next::fuchsia::HandleDecoder,
6916 {
6917 fn decode(
6918 mut slot: ::fidl_next::Slot<'_, Self>,
6919 decoder: &mut ___D,
6920 _: (),
6921 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6922 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6923 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6924 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirConnector>(
6925 raw,
6926 decoder,
6927 (),
6928 )?,
6929
6930 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6931 raw,
6932 decoder,
6933 (),
6934 )?,
6935
6936 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6937 }
6938
6939 Ok(())
6940 }
6941 }
6942
6943 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
6944 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6945 match self.raw.ordinal() {
6946 1 => unsafe {
6947 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
6948 },
6949 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6950 _ => unsafe { ::core::hint::unreachable_unchecked() },
6951 }
6952 }
6953 }
6954
6955 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
6956 type Natural = crate::natural::DirConnectorRouterRouteResponse;
6957 }
6958
6959 #[repr(transparent)]
6961 pub struct DirEntryRouterRouteResponse {
6962 pub(crate) raw: ::fidl_next::wire::Union,
6963 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6964 }
6965
6966 impl Drop for DirEntryRouterRouteResponse {
6967 fn drop(&mut self) {
6968 match self.raw.ordinal() {
6969 1 => {
6970 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
6971 }
6972
6973 2 => {
6974 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6975 }
6976
6977 _ => unsafe { ::core::hint::unreachable_unchecked() },
6978 }
6979 }
6980 }
6981
6982 impl ::fidl_next::Constrained for DirEntryRouterRouteResponse {
6983 type Constraint = ();
6984
6985 fn validate(
6986 _: ::fidl_next::Slot<'_, Self>,
6987 _: Self::Constraint,
6988 ) -> Result<(), ::fidl_next::ValidationError> {
6989 Ok(())
6990 }
6991 }
6992
6993 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
6994 type Narrowed<'de> = DirEntryRouterRouteResponse;
6995
6996 #[inline]
6997 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6998 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6999 ::fidl_next::wire::Union::zero_padding(raw);
7000 }
7001 }
7002
7003 pub mod dir_entry_router_route_response {
7004 pub enum Ref<'de> {
7005 DirEntry(&'de crate::wire::DirEntry),
7006
7007 Unavailable(&'de crate::wire::Unit),
7008 }
7009
7010 pub enum Value {
7011 DirEntry(crate::wire::DirEntry),
7012
7013 Unavailable(crate::wire::Unit),
7014 }
7015 }
7016
7017 impl DirEntryRouterRouteResponse {
7018 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
7019 match self.raw.ordinal() {
7020 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
7021 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
7022 }),
7023
7024 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
7025 self.raw.get().deref_unchecked::<crate::wire::Unit>()
7026 }),
7027
7028 _ => unsafe { ::core::hint::unreachable_unchecked() },
7029 }
7030 }
7031
7032 pub fn into_inner(self) -> crate::wire::dir_entry_router_route_response::Value {
7033 let this = ::core::mem::ManuallyDrop::new(self);
7034
7035 match this.raw.ordinal() {
7036 1 => crate::wire::dir_entry_router_route_response::Value::DirEntry(unsafe {
7037 this.raw.get().read_unchecked::<crate::wire::DirEntry>()
7038 }),
7039
7040 2 => crate::wire::dir_entry_router_route_response::Value::Unavailable(unsafe {
7041 this.raw.get().read_unchecked::<crate::wire::Unit>()
7042 }),
7043
7044 _ => unsafe { ::core::hint::unreachable_unchecked() },
7045 }
7046 }
7047 }
7048
7049 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
7050 where
7051 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7052 ___D: ::fidl_next::fuchsia::HandleDecoder,
7053 {
7054 fn decode(
7055 mut slot: ::fidl_next::Slot<'_, Self>,
7056 decoder: &mut ___D,
7057 _: (),
7058 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7059 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7060 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7061 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirEntry>(
7062 raw,
7063 decoder,
7064 (),
7065 )?,
7066
7067 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7068 raw,
7069 decoder,
7070 (),
7071 )?,
7072
7073 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
7074 }
7075
7076 Ok(())
7077 }
7078 }
7079
7080 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
7081 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7082 match self.raw.ordinal() {
7083 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
7084 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
7085 _ => unsafe { ::core::hint::unreachable_unchecked() },
7086 }
7087 }
7088 }
7089
7090 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
7091 type Natural = crate::natural::DirEntryRouterRouteResponse;
7092 }
7093
7094 #[repr(C)]
7096 pub struct DirReceiverReceiveRequest<'de> {
7097 pub(crate) table: ::fidl_next::wire::Table<'de>,
7098 }
7099
7100 impl<'de> Drop for DirReceiverReceiveRequest<'de> {
7101 fn drop(&mut self) {
7102 let _ = self.table.get(1).map(|envelope| unsafe {
7103 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
7104 });
7105
7106 let _ = self.table.get(2).map(|envelope| unsafe {
7107 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
7108 });
7109
7110 let _ = self.table.get(3).map(|envelope| unsafe {
7111 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
7112 });
7113 }
7114 }
7115
7116 impl ::fidl_next::Constrained for DirReceiverReceiveRequest<'_> {
7117 type Constraint = ();
7118
7119 fn validate(
7120 _: ::fidl_next::Slot<'_, Self>,
7121 _: Self::Constraint,
7122 ) -> Result<(), ::fidl_next::ValidationError> {
7123 Ok(())
7124 }
7125 }
7126
7127 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest<'static> {
7128 type Narrowed<'de> = DirReceiverReceiveRequest<'de>;
7129
7130 #[inline]
7131 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7132 ::fidl_next::munge!(let Self { table } = out);
7133 ::fidl_next::wire::Table::zero_padding(table);
7134 }
7135 }
7136
7137 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest<'de>
7138 where
7139 ___D: ::fidl_next::Decoder<'de> + ?Sized,
7140 ___D: ::fidl_next::fuchsia::HandleDecoder,
7141 {
7142 fn decode(
7143 slot: ::fidl_next::Slot<'_, Self>,
7144 decoder: &mut ___D,
7145 _: (),
7146 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7147 ::fidl_next::munge!(let Self { table } = slot);
7148
7149 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
7150 match ordinal {
7151 0 => unsafe { ::core::hint::unreachable_unchecked() },
7152
7153 1 => {
7154 ::fidl_next::wire::Envelope::decode_as::<
7155 ___D,
7156 ::fidl_next::wire::fuchsia::Channel,
7157 >(slot.as_mut(), decoder, ())?;
7158
7159 Ok(())
7160 }
7161
7162 2 => {
7163 ::fidl_next::wire::Envelope::decode_as::<
7164 ___D,
7165 ::fidl_next_fuchsia_io::wire::Flags,
7166 >(slot.as_mut(), decoder, ())?;
7167
7168 Ok(())
7169 }
7170
7171 3 => {
7172 ::fidl_next::wire::Envelope::decode_as::<
7173 ___D,
7174 ::fidl_next::wire::String<'de>,
7175 >(slot.as_mut(), decoder, 4095)?;
7176
7177 let value = unsafe {
7178 slot.deref_unchecked()
7179 .deref_unchecked::<::fidl_next::wire::String<'_>>()
7180 };
7181
7182 if value.len() > 4095 {
7183 return Err(::fidl_next::DecodeError::VectorTooLong {
7184 size: value.len() as u64,
7185 limit: 4095,
7186 });
7187 }
7188
7189 Ok(())
7190 }
7191
7192 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
7193 }
7194 })
7195 }
7196 }
7197
7198 impl<'de> DirReceiverReceiveRequest<'de> {
7199 pub fn channel(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
7200 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
7201 }
7202
7203 pub fn take_channel(
7204 &mut self,
7205 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Channel> {
7206 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
7207 }
7208
7209 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
7210 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
7211 }
7212
7213 pub fn take_flags(
7214 &mut self,
7215 ) -> ::core::option::Option<::fidl_next_fuchsia_io::wire::Flags> {
7216 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
7217 }
7218
7219 pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
7220 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
7221 }
7222
7223 pub fn take_subdir(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
7224 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
7225 }
7226 }
7227
7228 impl<'de> ::core::fmt::Debug for DirReceiverReceiveRequest<'de> {
7229 fn fmt(
7230 &self,
7231 f: &mut ::core::fmt::Formatter<'_>,
7232 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7233 f.debug_struct("DirReceiverReceiveRequest")
7234 .field("channel", &self.channel())
7235 .field("flags", &self.flags())
7236 .field("subdir", &self.subdir())
7237 .finish()
7238 }
7239 }
7240
7241 impl<'de> ::fidl_next::IntoNatural for DirReceiverReceiveRequest<'de> {
7242 type Natural = crate::natural::DirReceiverReceiveRequest;
7243 }
7244
7245 #[repr(transparent)]
7247 pub struct DirectoryRouterRouteResponse {
7248 pub(crate) raw: ::fidl_next::wire::Union,
7249 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7250 }
7251
7252 impl Drop for DirectoryRouterRouteResponse {
7253 fn drop(&mut self) {
7254 match self.raw.ordinal() {
7255 1 => {
7256 let _ = unsafe {
7257 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
7258 ::fidl_next_fuchsia_io::Directory,
7259 ::fidl_next::wire::fuchsia::Channel,
7260 >>()
7261 };
7262 }
7263
7264 2 => {
7265 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
7266 }
7267
7268 _ => unsafe { ::core::hint::unreachable_unchecked() },
7269 }
7270 }
7271 }
7272
7273 impl ::fidl_next::Constrained for DirectoryRouterRouteResponse {
7274 type Constraint = ();
7275
7276 fn validate(
7277 _: ::fidl_next::Slot<'_, Self>,
7278 _: Self::Constraint,
7279 ) -> Result<(), ::fidl_next::ValidationError> {
7280 Ok(())
7281 }
7282 }
7283
7284 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
7285 type Narrowed<'de> = DirectoryRouterRouteResponse;
7286
7287 #[inline]
7288 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7289 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7290 ::fidl_next::wire::Union::zero_padding(raw);
7291 }
7292 }
7293
7294 pub mod directory_router_route_response {
7295 pub enum Ref<'de> {
7296 Directory(
7297 &'de ::fidl_next::ClientEnd<
7298 ::fidl_next_fuchsia_io::Directory,
7299 ::fidl_next::wire::fuchsia::Channel,
7300 >,
7301 ),
7302
7303 Unavailable(&'de crate::wire::Unit),
7304 }
7305
7306 pub enum Value {
7307 Directory(
7308 ::fidl_next::ClientEnd<
7309 ::fidl_next_fuchsia_io::Directory,
7310 ::fidl_next::wire::fuchsia::Channel,
7311 >,
7312 ),
7313
7314 Unavailable(crate::wire::Unit),
7315 }
7316 }
7317
7318 impl DirectoryRouterRouteResponse {
7319 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
7320 match self.raw.ordinal() {
7321 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
7322 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
7323 ::fidl_next_fuchsia_io::Directory,
7324 ::fidl_next::wire::fuchsia::Channel,
7325 >>()
7326 }),
7327
7328 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
7329 self.raw.get().deref_unchecked::<crate::wire::Unit>()
7330 }),
7331
7332 _ => unsafe { ::core::hint::unreachable_unchecked() },
7333 }
7334 }
7335
7336 pub fn into_inner(self) -> crate::wire::directory_router_route_response::Value {
7337 let this = ::core::mem::ManuallyDrop::new(self);
7338
7339 match this.raw.ordinal() {
7340 1 => crate::wire::directory_router_route_response::Value::Directory(unsafe {
7341 this.raw.get().read_unchecked::<::fidl_next::ClientEnd<
7342 ::fidl_next_fuchsia_io::Directory,
7343 ::fidl_next::wire::fuchsia::Channel,
7344 >>()
7345 }),
7346
7347 2 => crate::wire::directory_router_route_response::Value::Unavailable(unsafe {
7348 this.raw.get().read_unchecked::<crate::wire::Unit>()
7349 }),
7350
7351 _ => unsafe { ::core::hint::unreachable_unchecked() },
7352 }
7353 }
7354 }
7355
7356 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
7357 where
7358 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7359 ___D: ::fidl_next::fuchsia::HandleDecoder,
7360 {
7361 fn decode(
7362 mut slot: ::fidl_next::Slot<'_, Self>,
7363 decoder: &mut ___D,
7364 _: (),
7365 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7366 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7367 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7368 1 => ::fidl_next::wire::Union::decode_as_static::<
7369 ___D,
7370 ::fidl_next::ClientEnd<
7371 ::fidl_next_fuchsia_io::Directory,
7372 ::fidl_next::wire::fuchsia::Channel,
7373 >,
7374 >(raw, decoder, ())?,
7375
7376 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7377 raw,
7378 decoder,
7379 (),
7380 )?,
7381
7382 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
7383 }
7384
7385 Ok(())
7386 }
7387 }
7388
7389 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
7390 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7391 match self.raw.ordinal() {
7392 1 => unsafe {
7393 self.raw
7394 .get()
7395 .deref_unchecked::<::fidl_next::ClientEnd<
7396 ::fidl_next_fuchsia_io::Directory,
7397 ::fidl_next::wire::fuchsia::Channel,
7398 >>()
7399 .fmt(f)
7400 },
7401 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
7402 _ => unsafe { ::core::hint::unreachable_unchecked() },
7403 }
7404 }
7405 }
7406
7407 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
7408 type Natural = crate::natural::DirectoryRouterRouteResponse;
7409 }
7410
7411 #[derive(Debug)]
7413 #[repr(C)]
7414 pub struct ProtocolPayload {
7415 pub channel: ::fidl_next::wire::fuchsia::Channel,
7416 }
7417
7418 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
7419 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
7420
7421 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
7422
7423 impl ::fidl_next::Constrained for ProtocolPayload {
7424 type Constraint = ();
7425
7426 fn validate(
7427 _: ::fidl_next::Slot<'_, Self>,
7428 _: Self::Constraint,
7429 ) -> Result<(), ::fidl_next::ValidationError> {
7430 Ok(())
7431 }
7432 }
7433
7434 unsafe impl ::fidl_next::Wire for ProtocolPayload {
7435 type Narrowed<'de> = ProtocolPayload;
7436
7437 #[inline]
7438 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7439 ::fidl_next::munge! {
7440 let Self {
7441 channel,
7442
7443 } = &mut *out_;
7444 }
7445
7446 ::fidl_next::Wire::zero_padding(channel);
7447 }
7448 }
7449
7450 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
7451 where
7452 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7453 ___D: ::fidl_next::fuchsia::HandleDecoder,
7454 {
7455 fn decode(
7456 slot_: ::fidl_next::Slot<'_, Self>,
7457 decoder_: &mut ___D,
7458 _: (),
7459 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7460 ::fidl_next::munge! {
7461 let Self {
7462 mut channel,
7463
7464 } = slot_;
7465 }
7466
7467 let _field = channel.as_mut();
7468
7469 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
7470
7471 Ok(())
7472 }
7473 }
7474
7475 impl ::fidl_next::IntoNatural for ProtocolPayload {
7476 type Natural = crate::natural::ProtocolPayload;
7477 }
7478}
7479
7480pub mod wire_optional {
7481
7482 pub use fidl_next_common_fuchsia_component_sandbox::wire_optional::*;
7483
7484 #[repr(transparent)]
7485 pub struct Capability<'de> {
7486 pub(crate) raw: ::fidl_next::wire::Union,
7487 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
7488 }
7489
7490 impl ::fidl_next::Constrained for Capability<'_> {
7491 type Constraint = ();
7492
7493 fn validate(
7494 _: ::fidl_next::Slot<'_, Self>,
7495 _: Self::Constraint,
7496 ) -> Result<(), ::fidl_next::ValidationError> {
7497 Ok(())
7498 }
7499 }
7500
7501 unsafe impl ::fidl_next::Wire for Capability<'static> {
7502 type Narrowed<'de> = Capability<'de>;
7503
7504 #[inline]
7505 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7506 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7507 ::fidl_next::wire::Union::zero_padding(raw);
7508 }
7509 }
7510
7511 impl<'de> Capability<'de> {
7512 pub fn is_some(&self) -> bool {
7513 self.raw.is_some()
7514 }
7515
7516 pub fn is_none(&self) -> bool {
7517 self.raw.is_none()
7518 }
7519
7520 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
7521 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7522 }
7523
7524 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
7525 if self.is_some() {
7526 Some(crate::wire::Capability {
7527 raw: self.raw,
7528 _phantom: ::core::marker::PhantomData,
7529 })
7530 } else {
7531 None
7532 }
7533 }
7534 }
7535
7536 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
7537 where
7538 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7539 ___D: ::fidl_next::Decoder<'de>,
7540 ___D: ::fidl_next::fuchsia::HandleDecoder,
7541 {
7542 fn decode(
7543 mut slot: ::fidl_next::Slot<'_, Self>,
7544 decoder: &mut ___D,
7545 _: (),
7546 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7547 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7548 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7549 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
7550 raw,
7551 decoder,
7552 (),
7553 )?,
7554
7555 2 => ::fidl_next::wire::Union::decode_as::<
7556 ___D,
7557 ::fidl_next::wire::fuchsia::NullableHandle,
7558 >(raw, decoder, ())?,
7559
7560 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
7561 raw,
7562 decoder,
7563 (),
7564 )?,
7565
7566 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DictionaryRef>(
7567 raw,
7568 decoder,
7569 (),
7570 )?,
7571
7572 5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Connector>(
7573 raw,
7574 decoder,
7575 (),
7576 )?,
7577
7578 6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirConnector>(
7579 raw,
7580 decoder,
7581 (),
7582 )?,
7583
7584 7 => ::fidl_next::wire::Union::decode_as::<
7585 ___D,
7586 ::fidl_next::ClientEnd<
7587 ::fidl_next_fuchsia_io::Directory,
7588 ::fidl_next::wire::fuchsia::Channel,
7589 >,
7590 >(raw, decoder, ())?,
7591
7592 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirEntry>(
7593 raw,
7594 decoder,
7595 (),
7596 )?,
7597
7598 9 => ::fidl_next::wire::Union::decode_as::<
7599 ___D,
7600 ::fidl_next::ClientEnd<
7601 crate::ConnectorRouter,
7602 ::fidl_next::wire::fuchsia::Channel,
7603 >,
7604 >(raw, decoder, ())?,
7605
7606 10 => ::fidl_next::wire::Union::decode_as::<
7607 ___D,
7608 ::fidl_next::ClientEnd<
7609 crate::DictionaryRouter,
7610 ::fidl_next::wire::fuchsia::Channel,
7611 >,
7612 >(raw, decoder, ())?,
7613
7614 11 => ::fidl_next::wire::Union::decode_as::<
7615 ___D,
7616 ::fidl_next::ClientEnd<
7617 crate::DirEntryRouter,
7618 ::fidl_next::wire::fuchsia::Channel,
7619 >,
7620 >(raw, decoder, ())?,
7621
7622 12 => ::fidl_next::wire::Union::decode_as::<
7623 ___D,
7624 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
7625 >(raw, decoder, ())?,
7626
7627 13 => ::fidl_next::wire::Union::decode_as::<
7628 ___D,
7629 ::fidl_next::ClientEnd<
7630 crate::DirConnectorRouter,
7631 ::fidl_next::wire::fuchsia::Channel,
7632 >,
7633 >(raw, decoder, ())?,
7634
7635 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7636 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
7637 }
7638
7639 Ok(())
7640 }
7641 }
7642
7643 impl<'de> ::core::fmt::Debug for Capability<'de> {
7644 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7645 self.as_ref().fmt(f)
7646 }
7647 }
7648
7649 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
7650 type Natural = ::core::option::Option<crate::natural::Capability>;
7651 }
7652
7653 #[repr(transparent)]
7654 pub struct ConnectorRouterRouteResponse {
7655 pub(crate) raw: ::fidl_next::wire::Union,
7656 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7657 }
7658
7659 impl ::fidl_next::Constrained for ConnectorRouterRouteResponse {
7660 type Constraint = ();
7661
7662 fn validate(
7663 _: ::fidl_next::Slot<'_, Self>,
7664 _: Self::Constraint,
7665 ) -> Result<(), ::fidl_next::ValidationError> {
7666 Ok(())
7667 }
7668 }
7669
7670 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
7671 type Narrowed<'de> = ConnectorRouterRouteResponse;
7672
7673 #[inline]
7674 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7675 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7676 ::fidl_next::wire::Union::zero_padding(raw);
7677 }
7678 }
7679
7680 impl ConnectorRouterRouteResponse {
7681 pub fn is_some(&self) -> bool {
7682 self.raw.is_some()
7683 }
7684
7685 pub fn is_none(&self) -> bool {
7686 self.raw.is_none()
7687 }
7688
7689 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
7690 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7691 }
7692
7693 pub fn into_option(
7694 self,
7695 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
7696 if self.is_some() {
7697 Some(crate::wire::ConnectorRouterRouteResponse {
7698 raw: self.raw,
7699 _phantom: ::core::marker::PhantomData,
7700 })
7701 } else {
7702 None
7703 }
7704 }
7705 }
7706
7707 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
7708 where
7709 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7710 ___D: ::fidl_next::fuchsia::HandleDecoder,
7711 {
7712 fn decode(
7713 mut slot: ::fidl_next::Slot<'_, Self>,
7714 decoder: &mut ___D,
7715 _: (),
7716 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7717 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7718 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7719 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Connector>(
7720 raw,
7721 decoder,
7722 (),
7723 )?,
7724
7725 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7726 raw,
7727 decoder,
7728 (),
7729 )?,
7730
7731 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7732 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7733 }
7734
7735 Ok(())
7736 }
7737 }
7738
7739 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
7740 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7741 self.as_ref().fmt(f)
7742 }
7743 }
7744
7745 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
7746 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
7747 }
7748
7749 #[repr(transparent)]
7750 pub struct DataRouterRouteResponse<'de> {
7751 pub(crate) raw: ::fidl_next::wire::Union,
7752 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
7753 }
7754
7755 impl ::fidl_next::Constrained for DataRouterRouteResponse<'_> {
7756 type Constraint = ();
7757
7758 fn validate(
7759 _: ::fidl_next::Slot<'_, Self>,
7760 _: Self::Constraint,
7761 ) -> Result<(), ::fidl_next::ValidationError> {
7762 Ok(())
7763 }
7764 }
7765
7766 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
7767 type Narrowed<'de> = DataRouterRouteResponse<'de>;
7768
7769 #[inline]
7770 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7771 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7772 ::fidl_next::wire::Union::zero_padding(raw);
7773 }
7774 }
7775
7776 impl<'de> DataRouterRouteResponse<'de> {
7777 pub fn is_some(&self) -> bool {
7778 self.raw.is_some()
7779 }
7780
7781 pub fn is_none(&self) -> bool {
7782 self.raw.is_none()
7783 }
7784
7785 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
7786 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7787 }
7788
7789 pub fn into_option(
7790 self,
7791 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
7792 if self.is_some() {
7793 Some(crate::wire::DataRouterRouteResponse {
7794 raw: self.raw,
7795 _phantom: ::core::marker::PhantomData,
7796 })
7797 } else {
7798 None
7799 }
7800 }
7801 }
7802
7803 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'de>
7804 where
7805 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7806 ___D: ::fidl_next::Decoder<'de>,
7807 ___D: ::fidl_next::fuchsia::HandleDecoder,
7808 {
7809 fn decode(
7810 mut slot: ::fidl_next::Slot<'_, Self>,
7811 decoder: &mut ___D,
7812 _: (),
7813 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7814 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7815 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7816 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
7817 raw,
7818 decoder,
7819 (),
7820 )?,
7821
7822 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
7823 raw,
7824 decoder,
7825 (),
7826 )?,
7827
7828 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7829 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
7830 }
7831
7832 Ok(())
7833 }
7834 }
7835
7836 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
7837 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7838 self.as_ref().fmt(f)
7839 }
7840 }
7841
7842 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
7843 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
7844 }
7845
7846 #[repr(transparent)]
7847 pub struct DictionaryRouterRouteResponse {
7848 pub(crate) raw: ::fidl_next::wire::Union,
7849 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7850 }
7851
7852 impl ::fidl_next::Constrained for DictionaryRouterRouteResponse {
7853 type Constraint = ();
7854
7855 fn validate(
7856 _: ::fidl_next::Slot<'_, Self>,
7857 _: Self::Constraint,
7858 ) -> Result<(), ::fidl_next::ValidationError> {
7859 Ok(())
7860 }
7861 }
7862
7863 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
7864 type Narrowed<'de> = DictionaryRouterRouteResponse;
7865
7866 #[inline]
7867 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7868 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7869 ::fidl_next::wire::Union::zero_padding(raw);
7870 }
7871 }
7872
7873 impl DictionaryRouterRouteResponse {
7874 pub fn is_some(&self) -> bool {
7875 self.raw.is_some()
7876 }
7877
7878 pub fn is_none(&self) -> bool {
7879 self.raw.is_none()
7880 }
7881
7882 pub fn as_ref(
7883 &self,
7884 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
7885 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7886 }
7887
7888 pub fn into_option(
7889 self,
7890 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
7891 if self.is_some() {
7892 Some(crate::wire::DictionaryRouterRouteResponse {
7893 raw: self.raw,
7894 _phantom: ::core::marker::PhantomData,
7895 })
7896 } else {
7897 None
7898 }
7899 }
7900 }
7901
7902 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
7903 where
7904 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7905 ___D: ::fidl_next::fuchsia::HandleDecoder,
7906 {
7907 fn decode(
7908 mut slot: ::fidl_next::Slot<'_, Self>,
7909 decoder: &mut ___D,
7910 _: (),
7911 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7912 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7913 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7914 1 => {
7915 ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DictionaryRef>(
7916 raw,
7917 decoder,
7918 (),
7919 )?
7920 }
7921
7922 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7923 raw,
7924 decoder,
7925 (),
7926 )?,
7927
7928 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7929 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7930 }
7931
7932 Ok(())
7933 }
7934 }
7935
7936 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
7937 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7938 self.as_ref().fmt(f)
7939 }
7940 }
7941
7942 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
7943 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
7944 }
7945
7946 #[repr(transparent)]
7947 pub struct DirConnectorRouterRouteResponse {
7948 pub(crate) raw: ::fidl_next::wire::Union,
7949 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7950 }
7951
7952 impl ::fidl_next::Constrained for DirConnectorRouterRouteResponse {
7953 type Constraint = ();
7954
7955 fn validate(
7956 _: ::fidl_next::Slot<'_, Self>,
7957 _: Self::Constraint,
7958 ) -> Result<(), ::fidl_next::ValidationError> {
7959 Ok(())
7960 }
7961 }
7962
7963 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
7964 type Narrowed<'de> = DirConnectorRouterRouteResponse;
7965
7966 #[inline]
7967 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7968 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7969 ::fidl_next::wire::Union::zero_padding(raw);
7970 }
7971 }
7972
7973 impl DirConnectorRouterRouteResponse {
7974 pub fn is_some(&self) -> bool {
7975 self.raw.is_some()
7976 }
7977
7978 pub fn is_none(&self) -> bool {
7979 self.raw.is_none()
7980 }
7981
7982 pub fn as_ref(
7983 &self,
7984 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
7985 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7986 }
7987
7988 pub fn into_option(
7989 self,
7990 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
7991 if self.is_some() {
7992 Some(crate::wire::DirConnectorRouterRouteResponse {
7993 raw: self.raw,
7994 _phantom: ::core::marker::PhantomData,
7995 })
7996 } else {
7997 None
7998 }
7999 }
8000 }
8001
8002 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
8003 where
8004 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8005 ___D: ::fidl_next::fuchsia::HandleDecoder,
8006 {
8007 fn decode(
8008 mut slot: ::fidl_next::Slot<'_, Self>,
8009 decoder: &mut ___D,
8010 _: (),
8011 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8012 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8013 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8014 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirConnector>(
8015 raw,
8016 decoder,
8017 (),
8018 )?,
8019
8020 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
8021 raw,
8022 decoder,
8023 (),
8024 )?,
8025
8026 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8027 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
8028 }
8029
8030 Ok(())
8031 }
8032 }
8033
8034 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
8035 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8036 self.as_ref().fmt(f)
8037 }
8038 }
8039
8040 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
8041 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
8042 }
8043
8044 #[repr(transparent)]
8045 pub struct DirEntryRouterRouteResponse {
8046 pub(crate) raw: ::fidl_next::wire::Union,
8047 pub(crate) _phantom: ::core::marker::PhantomData<()>,
8048 }
8049
8050 impl ::fidl_next::Constrained for DirEntryRouterRouteResponse {
8051 type Constraint = ();
8052
8053 fn validate(
8054 _: ::fidl_next::Slot<'_, Self>,
8055 _: Self::Constraint,
8056 ) -> Result<(), ::fidl_next::ValidationError> {
8057 Ok(())
8058 }
8059 }
8060
8061 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
8062 type Narrowed<'de> = DirEntryRouterRouteResponse;
8063
8064 #[inline]
8065 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8066 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8067 ::fidl_next::wire::Union::zero_padding(raw);
8068 }
8069 }
8070
8071 impl DirEntryRouterRouteResponse {
8072 pub fn is_some(&self) -> bool {
8073 self.raw.is_some()
8074 }
8075
8076 pub fn is_none(&self) -> bool {
8077 self.raw.is_none()
8078 }
8079
8080 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
8081 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
8082 }
8083
8084 pub fn into_option(
8085 self,
8086 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
8087 if self.is_some() {
8088 Some(crate::wire::DirEntryRouterRouteResponse {
8089 raw: self.raw,
8090 _phantom: ::core::marker::PhantomData,
8091 })
8092 } else {
8093 None
8094 }
8095 }
8096 }
8097
8098 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
8099 where
8100 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8101 ___D: ::fidl_next::fuchsia::HandleDecoder,
8102 {
8103 fn decode(
8104 mut slot: ::fidl_next::Slot<'_, Self>,
8105 decoder: &mut ___D,
8106 _: (),
8107 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8108 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8109 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8110 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirEntry>(
8111 raw,
8112 decoder,
8113 (),
8114 )?,
8115
8116 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
8117 raw,
8118 decoder,
8119 (),
8120 )?,
8121
8122 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8123 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
8124 }
8125
8126 Ok(())
8127 }
8128 }
8129
8130 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
8131 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8132 self.as_ref().fmt(f)
8133 }
8134 }
8135
8136 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
8137 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
8138 }
8139
8140 #[repr(transparent)]
8141 pub struct DirectoryRouterRouteResponse {
8142 pub(crate) raw: ::fidl_next::wire::Union,
8143 pub(crate) _phantom: ::core::marker::PhantomData<()>,
8144 }
8145
8146 impl ::fidl_next::Constrained for DirectoryRouterRouteResponse {
8147 type Constraint = ();
8148
8149 fn validate(
8150 _: ::fidl_next::Slot<'_, Self>,
8151 _: Self::Constraint,
8152 ) -> Result<(), ::fidl_next::ValidationError> {
8153 Ok(())
8154 }
8155 }
8156
8157 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
8158 type Narrowed<'de> = DirectoryRouterRouteResponse;
8159
8160 #[inline]
8161 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8162 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8163 ::fidl_next::wire::Union::zero_padding(raw);
8164 }
8165 }
8166
8167 impl DirectoryRouterRouteResponse {
8168 pub fn is_some(&self) -> bool {
8169 self.raw.is_some()
8170 }
8171
8172 pub fn is_none(&self) -> bool {
8173 self.raw.is_none()
8174 }
8175
8176 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
8177 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
8178 }
8179
8180 pub fn into_option(
8181 self,
8182 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
8183 if self.is_some() {
8184 Some(crate::wire::DirectoryRouterRouteResponse {
8185 raw: self.raw,
8186 _phantom: ::core::marker::PhantomData,
8187 })
8188 } else {
8189 None
8190 }
8191 }
8192 }
8193
8194 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
8195 where
8196 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8197 ___D: ::fidl_next::fuchsia::HandleDecoder,
8198 {
8199 fn decode(
8200 mut slot: ::fidl_next::Slot<'_, Self>,
8201 decoder: &mut ___D,
8202 _: (),
8203 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8204 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8205 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
8206 1 => ::fidl_next::wire::Union::decode_as_static::<
8207 ___D,
8208 ::fidl_next::ClientEnd<
8209 ::fidl_next_fuchsia_io::Directory,
8210 ::fidl_next::wire::fuchsia::Channel,
8211 >,
8212 >(raw, decoder, ())?,
8213
8214 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
8215 raw,
8216 decoder,
8217 (),
8218 )?,
8219
8220 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
8221 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
8222 }
8223
8224 Ok(())
8225 }
8226 }
8227
8228 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
8229 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8230 self.as_ref().fmt(f)
8231 }
8232 }
8233
8234 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
8235 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
8236 }
8237}
8238
8239pub mod generic {
8240
8241 pub use fidl_next_common_fuchsia_component_sandbox::generic::*;
8242
8243 pub struct DirConnector<T0> {
8245 pub token: T0,
8246 }
8247
8248 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector<T0>
8249 where
8250 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8251 ___E: ::fidl_next::fuchsia::HandleEncoder,
8252 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8253 {
8254 #[inline]
8255 fn encode(
8256 self,
8257 encoder_: &mut ___E,
8258 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
8259 _: (),
8260 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8261 ::fidl_next::munge! {
8262 let crate::wire::DirConnector {
8263 token,
8264
8265 } = out_;
8266 }
8267
8268 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8269
8270 Ok(())
8271 }
8272 }
8273
8274 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E>
8275 for &'a DirConnector<T0>
8276 where
8277 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8278 ___E: ::fidl_next::fuchsia::HandleEncoder,
8279 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8280 {
8281 #[inline]
8282 fn encode(
8283 self,
8284 encoder_: &mut ___E,
8285 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
8286 _: (),
8287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8288 ::fidl_next::munge! {
8289 let crate::wire::DirConnector {
8290 token,
8291
8292 } = out_;
8293 }
8294
8295 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
8296
8297 Ok(())
8298 }
8299 }
8300
8301 pub struct DictionaryRef<T0> {
8303 pub token: T0,
8304 }
8305
8306 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef<T0>
8307 where
8308 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8309 ___E: ::fidl_next::fuchsia::HandleEncoder,
8310 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8311 {
8312 #[inline]
8313 fn encode(
8314 self,
8315 encoder_: &mut ___E,
8316 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
8317 _: (),
8318 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8319 ::fidl_next::munge! {
8320 let crate::wire::DictionaryRef {
8321 token,
8322
8323 } = out_;
8324 }
8325
8326 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8327
8328 Ok(())
8329 }
8330 }
8331
8332 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E>
8333 for &'a DictionaryRef<T0>
8334 where
8335 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8336 ___E: ::fidl_next::fuchsia::HandleEncoder,
8337 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8338 {
8339 #[inline]
8340 fn encode(
8341 self,
8342 encoder_: &mut ___E,
8343 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
8344 _: (),
8345 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8346 ::fidl_next::munge! {
8347 let crate::wire::DictionaryRef {
8348 token,
8349
8350 } = out_;
8351 }
8352
8353 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
8354
8355 Ok(())
8356 }
8357 }
8358
8359 pub struct Connector<T0> {
8361 pub token: T0,
8362 }
8363
8364 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector<T0>
8365 where
8366 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8367 ___E: ::fidl_next::fuchsia::HandleEncoder,
8368 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8369 {
8370 #[inline]
8371 fn encode(
8372 self,
8373 encoder_: &mut ___E,
8374 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
8375 _: (),
8376 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8377 ::fidl_next::munge! {
8378 let crate::wire::Connector {
8379 token,
8380
8381 } = out_;
8382 }
8383
8384 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8385
8386 Ok(())
8387 }
8388 }
8389
8390 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for &'a Connector<T0>
8391 where
8392 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8393 ___E: ::fidl_next::fuchsia::HandleEncoder,
8394 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8395 {
8396 #[inline]
8397 fn encode(
8398 self,
8399 encoder_: &mut ___E,
8400 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
8401 _: (),
8402 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8403 ::fidl_next::munge! {
8404 let crate::wire::Connector {
8405 token,
8406
8407 } = out_;
8408 }
8409
8410 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
8411
8412 Ok(())
8413 }
8414 }
8415
8416 pub struct DirEntry<T0> {
8418 pub token: T0,
8419 }
8420
8421 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry<T0>
8422 where
8423 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8424 ___E: ::fidl_next::fuchsia::HandleEncoder,
8425 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8426 {
8427 #[inline]
8428 fn encode(
8429 self,
8430 encoder_: &mut ___E,
8431 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
8432 _: (),
8433 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8434 ::fidl_next::munge! {
8435 let crate::wire::DirEntry {
8436 token,
8437
8438 } = out_;
8439 }
8440
8441 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8442
8443 Ok(())
8444 }
8445 }
8446
8447 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for &'a DirEntry<T0>
8448 where
8449 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8450 ___E: ::fidl_next::fuchsia::HandleEncoder,
8451 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8452 {
8453 #[inline]
8454 fn encode(
8455 self,
8456 encoder_: &mut ___E,
8457 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
8458 _: (),
8459 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8460 ::fidl_next::munge! {
8461 let crate::wire::DirEntry {
8462 token,
8463
8464 } = out_;
8465 }
8466
8467 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
8468
8469 Ok(())
8470 }
8471 }
8472
8473 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
8475 pub id: T0,
8476
8477 pub receiver: T1,
8478 }
8479
8480 unsafe impl<___E, T0, T1>
8481 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
8482 for CapabilityStoreConnectorCreateRequest<T0, T1>
8483 where
8484 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8485 ___E: ::fidl_next::fuchsia::HandleEncoder,
8486 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8487 T1: ::fidl_next::Encode<
8488 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
8489 ___E,
8490 >,
8491 {
8492 #[inline]
8493 fn encode(
8494 self,
8495 encoder_: &mut ___E,
8496 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
8497 _: (),
8498 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8499 ::fidl_next::munge! {
8500 let crate::wire::CapabilityStoreConnectorCreateRequest {
8501 id,
8502 receiver,
8503
8504 } = out_;
8505 }
8506
8507 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8508
8509 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
8510
8511 Ok(())
8512 }
8513 }
8514
8515 unsafe impl<'a, ___E, T0, T1>
8516 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
8517 for &'a CapabilityStoreConnectorCreateRequest<T0, T1>
8518 where
8519 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8520 ___E: ::fidl_next::fuchsia::HandleEncoder,
8521 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8522 &'a T1: ::fidl_next::Encode<
8523 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
8524 ___E,
8525 >,
8526 {
8527 #[inline]
8528 fn encode(
8529 self,
8530 encoder_: &mut ___E,
8531 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
8532 _: (),
8533 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8534 ::fidl_next::munge! {
8535 let crate::wire::CapabilityStoreConnectorCreateRequest {
8536 id,
8537 receiver,
8538
8539 } = out_;
8540 }
8541
8542 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8543
8544 ::fidl_next::Encode::encode(&self.receiver, encoder_, receiver, ())?;
8545
8546 Ok(())
8547 }
8548 }
8549
8550 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
8552 pub id: T0,
8553
8554 pub server_end: T1,
8555 }
8556
8557 unsafe impl<___E, T0, T1>
8558 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
8559 for CapabilityStoreConnectorOpenRequest<T0, T1>
8560 where
8561 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8562 ___E: ::fidl_next::fuchsia::HandleEncoder,
8563 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8564 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8565 {
8566 #[inline]
8567 fn encode(
8568 self,
8569 encoder_: &mut ___E,
8570 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
8571 _: (),
8572 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8573 ::fidl_next::munge! {
8574 let crate::wire::CapabilityStoreConnectorOpenRequest {
8575 id,
8576 server_end,
8577
8578 } = out_;
8579 }
8580
8581 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8582
8583 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
8584
8585 Ok(())
8586 }
8587 }
8588
8589 unsafe impl<'a, ___E, T0, T1>
8590 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
8591 for &'a CapabilityStoreConnectorOpenRequest<T0, T1>
8592 where
8593 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8594 ___E: ::fidl_next::fuchsia::HandleEncoder,
8595 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8596 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8597 {
8598 #[inline]
8599 fn encode(
8600 self,
8601 encoder_: &mut ___E,
8602 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
8603 _: (),
8604 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8605 ::fidl_next::munge! {
8606 let crate::wire::CapabilityStoreConnectorOpenRequest {
8607 id,
8608 server_end,
8609
8610 } = out_;
8611 }
8612
8613 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8614
8615 ::fidl_next::Encode::encode(&self.server_end, encoder_, server_end, ())?;
8616
8617 Ok(())
8618 }
8619 }
8620
8621 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
8623 pub id: T0,
8624
8625 pub receiver: T1,
8626 }
8627
8628 unsafe impl<___E, T0, T1>
8629 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
8630 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
8631 where
8632 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8633 ___E: ::fidl_next::fuchsia::HandleEncoder,
8634 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8635 T1: ::fidl_next::Encode<
8636 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
8637 ___E,
8638 >,
8639 {
8640 #[inline]
8641 fn encode(
8642 self,
8643 encoder_: &mut ___E,
8644 out_: &mut ::core::mem::MaybeUninit<
8645 crate::wire::CapabilityStoreDirConnectorCreateRequest,
8646 >,
8647 _: (),
8648 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8649 ::fidl_next::munge! {
8650 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
8651 id,
8652 receiver,
8653
8654 } = out_;
8655 }
8656
8657 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8658
8659 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
8660
8661 Ok(())
8662 }
8663 }
8664
8665 unsafe impl<'a, ___E, T0, T1>
8666 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
8667 for &'a CapabilityStoreDirConnectorCreateRequest<T0, T1>
8668 where
8669 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8670 ___E: ::fidl_next::fuchsia::HandleEncoder,
8671 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8672 &'a T1: ::fidl_next::Encode<
8673 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
8674 ___E,
8675 >,
8676 {
8677 #[inline]
8678 fn encode(
8679 self,
8680 encoder_: &mut ___E,
8681 out_: &mut ::core::mem::MaybeUninit<
8682 crate::wire::CapabilityStoreDirConnectorCreateRequest,
8683 >,
8684 _: (),
8685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8686 ::fidl_next::munge! {
8687 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
8688 id,
8689 receiver,
8690
8691 } = out_;
8692 }
8693
8694 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8695
8696 ::fidl_next::Encode::encode(&self.receiver, encoder_, receiver, ())?;
8697
8698 Ok(())
8699 }
8700 }
8701
8702 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
8704 pub id: T0,
8705
8706 pub client_end: T1,
8707 }
8708
8709 unsafe impl<___E, T0, T1>
8710 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
8711 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
8712 where
8713 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8714 ___E: ::fidl_next::fuchsia::HandleEncoder,
8715 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8716 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8717 {
8718 #[inline]
8719 fn encode(
8720 self,
8721 encoder_: &mut ___E,
8722 out_: &mut ::core::mem::MaybeUninit<
8723 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
8724 >,
8725 _: (),
8726 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8727 ::fidl_next::munge! {
8728 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
8729 id,
8730 client_end,
8731
8732 } = out_;
8733 }
8734
8735 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8736
8737 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
8738
8739 Ok(())
8740 }
8741 }
8742
8743 unsafe impl<'a, ___E, T0, T1>
8744 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
8745 for &'a CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
8746 where
8747 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8748 ___E: ::fidl_next::fuchsia::HandleEncoder,
8749 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8750 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8751 {
8752 #[inline]
8753 fn encode(
8754 self,
8755 encoder_: &mut ___E,
8756 out_: &mut ::core::mem::MaybeUninit<
8757 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
8758 >,
8759 _: (),
8760 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8761 ::fidl_next::munge! {
8762 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
8763 id,
8764 client_end,
8765
8766 } = out_;
8767 }
8768
8769 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8770
8771 ::fidl_next::Encode::encode(&self.client_end, encoder_, client_end, ())?;
8772
8773 Ok(())
8774 }
8775 }
8776
8777 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
8779 pub id: T0,
8780
8781 pub server_end: T1,
8782 }
8783
8784 unsafe impl<___E, T0, T1>
8785 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
8786 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
8787 where
8788 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8789 ___E: ::fidl_next::fuchsia::HandleEncoder,
8790 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8791 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8792 {
8793 #[inline]
8794 fn encode(
8795 self,
8796 encoder_: &mut ___E,
8797 out_: &mut ::core::mem::MaybeUninit<
8798 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
8799 >,
8800 _: (),
8801 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8802 ::fidl_next::munge! {
8803 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
8804 id,
8805 server_end,
8806
8807 } = out_;
8808 }
8809
8810 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8811
8812 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
8813
8814 Ok(())
8815 }
8816 }
8817
8818 unsafe impl<'a, ___E, T0, T1>
8819 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
8820 for &'a CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
8821 where
8822 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8823 ___E: ::fidl_next::fuchsia::HandleEncoder,
8824 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8825 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8826 {
8827 #[inline]
8828 fn encode(
8829 self,
8830 encoder_: &mut ___E,
8831 out_: &mut ::core::mem::MaybeUninit<
8832 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
8833 >,
8834 _: (),
8835 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8836 ::fidl_next::munge! {
8837 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
8838 id,
8839 server_end,
8840
8841 } = out_;
8842 }
8843
8844 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8845
8846 ::fidl_next::Encode::encode(&self.server_end, encoder_, server_end, ())?;
8847
8848 Ok(())
8849 }
8850 }
8851
8852 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
8854 pub id: T0,
8855
8856 pub iterator: T1,
8857 }
8858
8859 unsafe impl<___E, T0, T1>
8860 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
8861 for CapabilityStoreDictionaryKeysRequest<T0, T1>
8862 where
8863 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8864 ___E: ::fidl_next::fuchsia::HandleEncoder,
8865 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8866 T1: ::fidl_next::Encode<
8867 ::fidl_next::ServerEnd<
8868 crate::DictionaryKeysIterator,
8869 ::fidl_next::wire::fuchsia::Channel,
8870 >,
8871 ___E,
8872 >,
8873 {
8874 #[inline]
8875 fn encode(
8876 self,
8877 encoder_: &mut ___E,
8878 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
8879 _: (),
8880 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8881 ::fidl_next::munge! {
8882 let crate::wire::CapabilityStoreDictionaryKeysRequest {
8883 id,
8884 iterator,
8885
8886 } = out_;
8887 }
8888
8889 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8890
8891 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8892
8893 Ok(())
8894 }
8895 }
8896
8897 unsafe impl<'a, ___E, T0, T1>
8898 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
8899 for &'a CapabilityStoreDictionaryKeysRequest<T0, T1>
8900 where
8901 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8902 ___E: ::fidl_next::fuchsia::HandleEncoder,
8903 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8904 &'a T1: ::fidl_next::Encode<
8905 ::fidl_next::ServerEnd<
8906 crate::DictionaryKeysIterator,
8907 ::fidl_next::wire::fuchsia::Channel,
8908 >,
8909 ___E,
8910 >,
8911 {
8912 #[inline]
8913 fn encode(
8914 self,
8915 encoder_: &mut ___E,
8916 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
8917 _: (),
8918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8919 ::fidl_next::munge! {
8920 let crate::wire::CapabilityStoreDictionaryKeysRequest {
8921 id,
8922 iterator,
8923
8924 } = out_;
8925 }
8926
8927 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
8928
8929 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
8930
8931 Ok(())
8932 }
8933 }
8934
8935 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
8937 pub id: T0,
8938
8939 pub iterator: T1,
8940 }
8941
8942 unsafe impl<___E, T0, T1>
8943 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
8944 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
8945 where
8946 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8947 ___E: ::fidl_next::fuchsia::HandleEncoder,
8948 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8949 T1: ::fidl_next::Encode<
8950 ::fidl_next::ServerEnd<
8951 crate::DictionaryEnumerateIterator,
8952 ::fidl_next::wire::fuchsia::Channel,
8953 >,
8954 ___E,
8955 >,
8956 {
8957 #[inline]
8958 fn encode(
8959 self,
8960 encoder_: &mut ___E,
8961 out_: &mut ::core::mem::MaybeUninit<
8962 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
8963 >,
8964 _: (),
8965 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8966 ::fidl_next::munge! {
8967 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
8968 id,
8969 iterator,
8970
8971 } = out_;
8972 }
8973
8974 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8975
8976 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8977
8978 Ok(())
8979 }
8980 }
8981
8982 unsafe impl<'a, ___E, T0, T1>
8983 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
8984 for &'a CapabilityStoreDictionaryEnumerateRequest<T0, T1>
8985 where
8986 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8987 ___E: ::fidl_next::fuchsia::HandleEncoder,
8988 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8989 &'a T1: ::fidl_next::Encode<
8990 ::fidl_next::ServerEnd<
8991 crate::DictionaryEnumerateIterator,
8992 ::fidl_next::wire::fuchsia::Channel,
8993 >,
8994 ___E,
8995 >,
8996 {
8997 #[inline]
8998 fn encode(
8999 self,
9000 encoder_: &mut ___E,
9001 out_: &mut ::core::mem::MaybeUninit<
9002 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
9003 >,
9004 _: (),
9005 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9006 ::fidl_next::munge! {
9007 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
9008 id,
9009 iterator,
9010
9011 } = out_;
9012 }
9013
9014 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
9015
9016 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
9017
9018 Ok(())
9019 }
9020 }
9021
9022 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
9024 pub id: T0,
9025
9026 pub iterator: T1,
9027 }
9028
9029 unsafe impl<___E, T0, T1>
9030 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
9031 for CapabilityStoreDictionaryDrainRequest<T0, T1>
9032 where
9033 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9034 ___E: ::fidl_next::fuchsia::HandleEncoder,
9035 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9036 T1: ::fidl_next::Encode<
9037 ::fidl_next::ServerEnd<
9038 crate::DictionaryDrainIterator,
9039 ::fidl_next::wire::fuchsia::OptionalChannel,
9040 >,
9041 ___E,
9042 >,
9043 {
9044 #[inline]
9045 fn encode(
9046 self,
9047 encoder_: &mut ___E,
9048 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
9049 _: (),
9050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9051 ::fidl_next::munge! {
9052 let crate::wire::CapabilityStoreDictionaryDrainRequest {
9053 id,
9054 iterator,
9055
9056 } = out_;
9057 }
9058
9059 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
9060
9061 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
9062
9063 Ok(())
9064 }
9065 }
9066
9067 unsafe impl<'a, ___E, T0, T1>
9068 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
9069 for &'a CapabilityStoreDictionaryDrainRequest<T0, T1>
9070 where
9071 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9072 ___E: ::fidl_next::fuchsia::HandleEncoder,
9073 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9074 &'a T1: ::fidl_next::Encode<
9075 ::fidl_next::ServerEnd<
9076 crate::DictionaryDrainIterator,
9077 ::fidl_next::wire::fuchsia::OptionalChannel,
9078 >,
9079 ___E,
9080 >,
9081 {
9082 #[inline]
9083 fn encode(
9084 self,
9085 encoder_: &mut ___E,
9086 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
9087 _: (),
9088 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9089 ::fidl_next::munge! {
9090 let crate::wire::CapabilityStoreDictionaryDrainRequest {
9091 id,
9092 iterator,
9093
9094 } = out_;
9095 }
9096
9097 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
9098
9099 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
9100
9101 Ok(())
9102 }
9103 }
9104
9105 pub struct CapabilityStoreCreateServiceAggregateRequest<T0> {
9107 pub sources: T0,
9108 }
9109
9110 unsafe impl<___E, T0>
9111 ::fidl_next::Encode<
9112 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
9113 ___E,
9114 > for CapabilityStoreCreateServiceAggregateRequest<T0>
9115 where
9116 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9117 ___E: ::fidl_next::Encoder,
9118 ___E: ::fidl_next::fuchsia::HandleEncoder,
9119 T0: ::fidl_next::Encode<
9120 ::fidl_next::wire::Vector<'static, crate::wire::AggregateSource<'static>>,
9121 ___E,
9122 >,
9123 {
9124 #[inline]
9125 fn encode(
9126 self,
9127 encoder_: &mut ___E,
9128 out_: &mut ::core::mem::MaybeUninit<
9129 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
9130 >,
9131 _: (),
9132 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9133 ::fidl_next::munge! {
9134 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
9135 sources,
9136
9137 } = out_;
9138 }
9139
9140 ::fidl_next::Encode::encode(self.sources, encoder_, sources, (4294967295, ()))?;
9141
9142 Ok(())
9143 }
9144 }
9145
9146 unsafe impl<'a, ___E, T0>
9147 ::fidl_next::Encode<
9148 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
9149 ___E,
9150 > for &'a CapabilityStoreCreateServiceAggregateRequest<T0>
9151 where
9152 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9153 ___E: ::fidl_next::Encoder,
9154 ___E: ::fidl_next::fuchsia::HandleEncoder,
9155 &'a T0: ::fidl_next::Encode<
9156 ::fidl_next::wire::Vector<'static, crate::wire::AggregateSource<'static>>,
9157 ___E,
9158 >,
9159 {
9160 #[inline]
9161 fn encode(
9162 self,
9163 encoder_: &mut ___E,
9164 out_: &mut ::core::mem::MaybeUninit<
9165 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
9166 >,
9167 _: (),
9168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9169 ::fidl_next::munge! {
9170 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
9171 sources,
9172
9173 } = out_;
9174 }
9175
9176 ::fidl_next::Encode::encode(&self.sources, encoder_, sources, (4294967295, ()))?;
9177
9178 Ok(())
9179 }
9180 }
9181
9182 pub struct CapabilityStoreCreateServiceAggregateResponse<T0> {
9184 pub aggregate_dir_connector: T0,
9185 }
9186
9187 unsafe impl<___E, T0>
9188 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
9189 for CapabilityStoreCreateServiceAggregateResponse<T0>
9190 where
9191 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9192 ___E: ::fidl_next::fuchsia::HandleEncoder,
9193 T0: ::fidl_next::Encode<crate::wire::DirConnector, ___E>,
9194 {
9195 #[inline]
9196 fn encode(
9197 self,
9198 encoder_: &mut ___E,
9199 out_: &mut ::core::mem::MaybeUninit<
9200 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
9201 >,
9202 _: (),
9203 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9204 ::fidl_next::munge! {
9205 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
9206 aggregate_dir_connector,
9207
9208 } = out_;
9209 }
9210
9211 ::fidl_next::Encode::encode(
9212 self.aggregate_dir_connector,
9213 encoder_,
9214 aggregate_dir_connector,
9215 (),
9216 )?;
9217
9218 Ok(())
9219 }
9220 }
9221
9222 unsafe impl<'a, ___E, T0>
9223 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
9224 for &'a CapabilityStoreCreateServiceAggregateResponse<T0>
9225 where
9226 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9227 ___E: ::fidl_next::fuchsia::HandleEncoder,
9228 &'a T0: ::fidl_next::Encode<crate::wire::DirConnector, ___E>,
9229 {
9230 #[inline]
9231 fn encode(
9232 self,
9233 encoder_: &mut ___E,
9234 out_: &mut ::core::mem::MaybeUninit<
9235 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
9236 >,
9237 _: (),
9238 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9239 ::fidl_next::munge! {
9240 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
9241 aggregate_dir_connector,
9242
9243 } = out_;
9244 }
9245
9246 ::fidl_next::Encode::encode(
9247 &self.aggregate_dir_connector,
9248 encoder_,
9249 aggregate_dir_connector,
9250 (),
9251 )?;
9252
9253 Ok(())
9254 }
9255 }
9256
9257 pub struct CapabilityStoreExportResponse<T0> {
9259 pub capability: T0,
9260 }
9261
9262 unsafe impl<___E, T0>
9263 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
9264 for CapabilityStoreExportResponse<T0>
9265 where
9266 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9267 ___E: ::fidl_next::Encoder,
9268 ___E: ::fidl_next::fuchsia::HandleEncoder,
9269 T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
9270 {
9271 #[inline]
9272 fn encode(
9273 self,
9274 encoder_: &mut ___E,
9275 out_: &mut ::core::mem::MaybeUninit<
9276 crate::wire::CapabilityStoreExportResponse<'static>,
9277 >,
9278 _: (),
9279 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9280 ::fidl_next::munge! {
9281 let crate::wire::CapabilityStoreExportResponse {
9282 capability,
9283
9284 } = out_;
9285 }
9286
9287 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
9288
9289 Ok(())
9290 }
9291 }
9292
9293 unsafe impl<'a, ___E, T0>
9294 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
9295 for &'a CapabilityStoreExportResponse<T0>
9296 where
9297 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9298 ___E: ::fidl_next::Encoder,
9299 ___E: ::fidl_next::fuchsia::HandleEncoder,
9300 &'a T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
9301 {
9302 #[inline]
9303 fn encode(
9304 self,
9305 encoder_: &mut ___E,
9306 out_: &mut ::core::mem::MaybeUninit<
9307 crate::wire::CapabilityStoreExportResponse<'static>,
9308 >,
9309 _: (),
9310 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9311 ::fidl_next::munge! {
9312 let crate::wire::CapabilityStoreExportResponse {
9313 capability,
9314
9315 } = out_;
9316 }
9317
9318 ::fidl_next::Encode::encode(&self.capability, encoder_, capability, ())?;
9319
9320 Ok(())
9321 }
9322 }
9323
9324 pub struct CapabilityStoreImportRequest<T0, T1> {
9326 pub id: T0,
9327
9328 pub capability: T1,
9329 }
9330
9331 unsafe impl<___E, T0, T1>
9332 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
9333 for CapabilityStoreImportRequest<T0, T1>
9334 where
9335 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9336 ___E: ::fidl_next::Encoder,
9337 ___E: ::fidl_next::fuchsia::HandleEncoder,
9338 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9339 T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
9340 {
9341 #[inline]
9342 fn encode(
9343 self,
9344 encoder_: &mut ___E,
9345 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
9346 _: (),
9347 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9348 ::fidl_next::munge! {
9349 let crate::wire::CapabilityStoreImportRequest {
9350 id,
9351 capability,
9352
9353 } = out_;
9354 }
9355
9356 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
9357
9358 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
9359
9360 Ok(())
9361 }
9362 }
9363
9364 unsafe impl<'a, ___E, T0, T1>
9365 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
9366 for &'a CapabilityStoreImportRequest<T0, T1>
9367 where
9368 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9369 ___E: ::fidl_next::Encoder,
9370 ___E: ::fidl_next::fuchsia::HandleEncoder,
9371 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9372 &'a T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
9373 {
9374 #[inline]
9375 fn encode(
9376 self,
9377 encoder_: &mut ___E,
9378 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
9379 _: (),
9380 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9381 ::fidl_next::munge! {
9382 let crate::wire::CapabilityStoreImportRequest {
9383 id,
9384 capability,
9385
9386 } = out_;
9387 }
9388
9389 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
9390
9391 ::fidl_next::Encode::encode(&self.capability, encoder_, capability, ())?;
9392
9393 Ok(())
9394 }
9395 }
9396
9397 pub struct InstanceToken<T0> {
9399 pub token: T0,
9400 }
9401
9402 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken<T0>
9403 where
9404 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9405 ___E: ::fidl_next::fuchsia::HandleEncoder,
9406 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
9407 {
9408 #[inline]
9409 fn encode(
9410 self,
9411 encoder_: &mut ___E,
9412 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
9413 _: (),
9414 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9415 ::fidl_next::munge! {
9416 let crate::wire::InstanceToken {
9417 token,
9418
9419 } = out_;
9420 }
9421
9422 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
9423
9424 Ok(())
9425 }
9426 }
9427
9428 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E>
9429 for &'a InstanceToken<T0>
9430 where
9431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9432 ___E: ::fidl_next::fuchsia::HandleEncoder,
9433 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
9434 {
9435 #[inline]
9436 fn encode(
9437 self,
9438 encoder_: &mut ___E,
9439 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
9440 _: (),
9441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9442 ::fidl_next::munge! {
9443 let crate::wire::InstanceToken {
9444 token,
9445
9446 } = out_;
9447 }
9448
9449 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
9450
9451 Ok(())
9452 }
9453 }
9454
9455 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
9457 pub items: T0,
9458
9459 pub end_id: T1,
9460 }
9461
9462 unsafe impl<___E, T0, T1>
9463 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
9464 for DictionaryDrainIteratorGetNextResponse<T0, T1>
9465 where
9466 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9467 ___E: ::fidl_next::Encoder,
9468 ___E: ::fidl_next::fuchsia::HandleEncoder,
9469 T0: ::fidl_next::Encode<
9470 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryItem<'static>>,
9471 ___E,
9472 >,
9473 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9474 {
9475 #[inline]
9476 fn encode(
9477 self,
9478 encoder_: &mut ___E,
9479 out_: &mut ::core::mem::MaybeUninit<
9480 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
9481 >,
9482 _: (),
9483 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9484 ::fidl_next::munge! {
9485 let crate::wire::DictionaryDrainIteratorGetNextResponse {
9486 items,
9487 end_id,
9488
9489 } = out_;
9490 }
9491
9492 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
9493
9494 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
9495
9496 Ok(())
9497 }
9498 }
9499
9500 unsafe impl<'a, ___E, T0, T1>
9501 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
9502 for &'a DictionaryDrainIteratorGetNextResponse<T0, T1>
9503 where
9504 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9505 ___E: ::fidl_next::Encoder,
9506 ___E: ::fidl_next::fuchsia::HandleEncoder,
9507 &'a T0: ::fidl_next::Encode<
9508 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryItem<'static>>,
9509 ___E,
9510 >,
9511 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9512 {
9513 #[inline]
9514 fn encode(
9515 self,
9516 encoder_: &mut ___E,
9517 out_: &mut ::core::mem::MaybeUninit<
9518 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
9519 >,
9520 _: (),
9521 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9522 ::fidl_next::munge! {
9523 let crate::wire::DictionaryDrainIteratorGetNextResponse {
9524 items,
9525 end_id,
9526
9527 } = out_;
9528 }
9529
9530 ::fidl_next::Encode::encode(&self.items, encoder_, items, (128, ()))?;
9531
9532 ::fidl_next::Encode::encode(&self.end_id, encoder_, end_id, ())?;
9533
9534 Ok(())
9535 }
9536 }
9537
9538 pub struct DictionaryOptionalItem<T0, T1> {
9540 pub key: T0,
9541
9542 pub value: T1,
9543 }
9544
9545 unsafe impl<___E, T0, T1>
9546 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
9547 for DictionaryOptionalItem<T0, T1>
9548 where
9549 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9550 ___E: ::fidl_next::Encoder,
9551 ___E: ::fidl_next::fuchsia::HandleEncoder,
9552 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
9553 T1: ::fidl_next::Encode<
9554 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
9555 ___E,
9556 >,
9557 {
9558 #[inline]
9559 fn encode(
9560 self,
9561 encoder_: &mut ___E,
9562 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
9563 _: (),
9564 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9565 ::fidl_next::munge! {
9566 let crate::wire::DictionaryOptionalItem {
9567 key,
9568 value,
9569
9570 } = out_;
9571 }
9572
9573 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
9574
9575 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
9576
9577 Ok(())
9578 }
9579 }
9580
9581 unsafe impl<'a, ___E, T0, T1>
9582 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
9583 for &'a DictionaryOptionalItem<T0, T1>
9584 where
9585 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9586 ___E: ::fidl_next::Encoder,
9587 ___E: ::fidl_next::fuchsia::HandleEncoder,
9588 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
9589 &'a T1: ::fidl_next::Encode<
9590 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
9591 ___E,
9592 >,
9593 {
9594 #[inline]
9595 fn encode(
9596 self,
9597 encoder_: &mut ___E,
9598 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
9599 _: (),
9600 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9601 ::fidl_next::munge! {
9602 let crate::wire::DictionaryOptionalItem {
9603 key,
9604 value,
9605
9606 } = out_;
9607 }
9608
9609 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
9610
9611 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
9612
9613 Ok(())
9614 }
9615 }
9616
9617 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
9619 pub items: T0,
9620
9621 pub end_id: T1,
9622 }
9623
9624 unsafe impl<___E, T0, T1>
9625 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
9626 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
9627 where
9628 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9629 ___E: ::fidl_next::Encoder,
9630 ___E: ::fidl_next::fuchsia::HandleEncoder,
9631 T0: ::fidl_next::Encode<
9632 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryOptionalItem<'static>>,
9633 ___E,
9634 >,
9635 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9636 {
9637 #[inline]
9638 fn encode(
9639 self,
9640 encoder_: &mut ___E,
9641 out_: &mut ::core::mem::MaybeUninit<
9642 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
9643 >,
9644 _: (),
9645 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9646 ::fidl_next::munge! {
9647 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
9648 items,
9649 end_id,
9650
9651 } = out_;
9652 }
9653
9654 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
9655
9656 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
9657
9658 Ok(())
9659 }
9660 }
9661
9662 unsafe impl<'a, ___E, T0, T1>
9663 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
9664 for &'a DictionaryEnumerateIteratorGetNextResponse<T0, T1>
9665 where
9666 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9667 ___E: ::fidl_next::Encoder,
9668 ___E: ::fidl_next::fuchsia::HandleEncoder,
9669 &'a T0: ::fidl_next::Encode<
9670 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryOptionalItem<'static>>,
9671 ___E,
9672 >,
9673 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
9674 {
9675 #[inline]
9676 fn encode(
9677 self,
9678 encoder_: &mut ___E,
9679 out_: &mut ::core::mem::MaybeUninit<
9680 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
9681 >,
9682 _: (),
9683 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9684 ::fidl_next::munge! {
9685 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
9686 items,
9687 end_id,
9688
9689 } = out_;
9690 }
9691
9692 ::fidl_next::Encode::encode(&self.items, encoder_, items, (128, ()))?;
9693
9694 ::fidl_next::Encode::encode(&self.end_id, encoder_, end_id, ())?;
9695
9696 Ok(())
9697 }
9698 }
9699
9700 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
9702 pub keys: T0,
9703 }
9704
9705 unsafe impl<___E, T0>
9706 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
9707 for DictionaryKeysIteratorGetNextResponse<T0>
9708 where
9709 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9710 ___E: ::fidl_next::Encoder,
9711 ___E: ::fidl_next::fuchsia::HandleEncoder,
9712 T0: ::fidl_next::Encode<
9713 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
9714 ___E,
9715 >,
9716 {
9717 #[inline]
9718 fn encode(
9719 self,
9720 encoder_: &mut ___E,
9721 out_: &mut ::core::mem::MaybeUninit<
9722 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
9723 >,
9724 _: (),
9725 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9726 ::fidl_next::munge! {
9727 let crate::wire::DictionaryKeysIteratorGetNextResponse {
9728 keys,
9729
9730 } = out_;
9731 }
9732
9733 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
9734
9735 Ok(())
9736 }
9737 }
9738
9739 unsafe impl<'a, ___E, T0>
9740 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
9741 for &'a DictionaryKeysIteratorGetNextResponse<T0>
9742 where
9743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9744 ___E: ::fidl_next::Encoder,
9745 ___E: ::fidl_next::fuchsia::HandleEncoder,
9746 &'a T0: ::fidl_next::Encode<
9747 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
9748 ___E,
9749 >,
9750 {
9751 #[inline]
9752 fn encode(
9753 self,
9754 encoder_: &mut ___E,
9755 out_: &mut ::core::mem::MaybeUninit<
9756 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
9757 >,
9758 _: (),
9759 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9760 ::fidl_next::munge! {
9761 let crate::wire::DictionaryKeysIteratorGetNextResponse {
9762 keys,
9763
9764 } = out_;
9765 }
9766
9767 ::fidl_next::Encode::encode(&self.keys, encoder_, keys, (128, 255))?;
9768
9769 Ok(())
9770 }
9771 }
9772
9773 pub struct ProtocolPayload<T0> {
9775 pub channel: T0,
9776 }
9777
9778 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
9779 for ProtocolPayload<T0>
9780 where
9781 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9782 ___E: ::fidl_next::fuchsia::HandleEncoder,
9783 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
9784 {
9785 #[inline]
9786 fn encode(
9787 self,
9788 encoder_: &mut ___E,
9789 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
9790 _: (),
9791 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9792 ::fidl_next::munge! {
9793 let crate::wire::ProtocolPayload {
9794 channel,
9795
9796 } = out_;
9797 }
9798
9799 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
9800
9801 Ok(())
9802 }
9803 }
9804
9805 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
9806 for &'a ProtocolPayload<T0>
9807 where
9808 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9809 ___E: ::fidl_next::fuchsia::HandleEncoder,
9810 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
9811 {
9812 #[inline]
9813 fn encode(
9814 self,
9815 encoder_: &mut ___E,
9816 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
9817 _: (),
9818 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9819 ::fidl_next::munge! {
9820 let crate::wire::ProtocolPayload {
9821 channel,
9822
9823 } = out_;
9824 }
9825
9826 ::fidl_next::Encode::encode(&self.channel, encoder_, channel, ())?;
9827
9828 Ok(())
9829 }
9830 }
9831}
9832
9833pub use self::natural::*;
9834
9835#[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"]
9837#[derive(PartialEq, Debug)]
9838pub struct CapabilityStore;
9839
9840impl ::fidl_next::Discoverable for CapabilityStore {
9841 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
9842}
9843
9844#[cfg(target_os = "fuchsia")]
9845impl ::fidl_next::HasTransport for CapabilityStore {
9846 type Transport = ::fidl_next::fuchsia::zx::Channel;
9847}
9848
9849pub mod capability_store {
9850 pub mod prelude {
9851 pub use crate::{
9852 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreLocalClientHandler,
9853 CapabilityStoreLocalServerHandler, CapabilityStoreServerHandler, capability_store,
9854 };
9855
9856 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
9857
9858 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
9859
9860 pub use crate::natural::CapabilityStoreCreateServiceAggregateRequest;
9861
9862 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
9863
9864 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
9865
9866 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
9867
9868 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
9869
9870 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
9871
9872 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
9873
9874 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
9875
9876 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
9877
9878 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
9879
9880 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
9881
9882 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
9883
9884 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
9885
9886 pub use crate::natural::CapabilityStoreDropRequest;
9887
9888 pub use crate::natural::CapabilityStoreDuplicateRequest;
9889
9890 pub use crate::natural::CapabilityStoreError;
9891
9892 pub use crate::natural::CapabilityStoreExportRequest;
9893
9894 pub use crate::natural::CapabilityStoreImportRequest;
9895
9896 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
9897
9898 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
9899
9900 pub use crate::natural::CapabilityStoreCreateServiceAggregateResponse;
9901
9902 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
9903
9904 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
9905
9906 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
9907
9908 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
9909
9910 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
9911
9912 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
9913
9914 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
9915
9916 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
9917
9918 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
9919
9920 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
9921
9922 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
9923
9924 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
9925
9926 pub use crate::natural::CapabilityStoreDropResponse;
9927
9928 pub use crate::natural::CapabilityStoreDuplicateResponse;
9929
9930 pub use crate::natural::CapabilityStoreExportResponse;
9931
9932 pub use crate::natural::CapabilityStoreImportResponse;
9933 }
9934
9935 pub struct Duplicate;
9936
9937 impl ::fidl_next::Method for Duplicate {
9938 const ORDINAL: u64 = 6727592627741008260;
9939 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9940 ::fidl_next::protocol::Flexibility::Flexible;
9941
9942 type Protocol = crate::CapabilityStore;
9943
9944 type Request = crate::wire::CapabilityStoreDuplicateRequest;
9945 }
9946
9947 impl ::fidl_next::TwoWayMethod for Duplicate {
9948 type Response = ::fidl_next::wire::Result<
9949 'static,
9950 crate::wire::CapabilityStoreDuplicateResponse,
9951 crate::wire::CapabilityStoreError,
9952 >;
9953 }
9954
9955 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
9956 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9957
9958 fn respond(response: ___R) -> Self::Output {
9959 ::core::result::Result::Ok(response)
9960 }
9961 }
9962
9963 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
9964 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9965
9966 fn respond_err(response: ___R) -> Self::Output {
9967 ::core::result::Result::Err(response)
9968 }
9969 }
9970
9971 pub struct Drop;
9972
9973 impl ::fidl_next::Method for Drop {
9974 const ORDINAL: u64 = 753328233834620249;
9975 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9976 ::fidl_next::protocol::Flexibility::Flexible;
9977
9978 type Protocol = crate::CapabilityStore;
9979
9980 type Request = crate::wire::CapabilityStoreDropRequest;
9981 }
9982
9983 impl ::fidl_next::TwoWayMethod for Drop {
9984 type Response = ::fidl_next::wire::Result<
9985 'static,
9986 crate::wire::CapabilityStoreDropResponse,
9987 crate::wire::CapabilityStoreError,
9988 >;
9989 }
9990
9991 impl<___R> ::fidl_next::Respond<___R> for Drop {
9992 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9993
9994 fn respond(response: ___R) -> Self::Output {
9995 ::core::result::Result::Ok(response)
9996 }
9997 }
9998
9999 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
10000 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10001
10002 fn respond_err(response: ___R) -> Self::Output {
10003 ::core::result::Result::Err(response)
10004 }
10005 }
10006
10007 pub struct Export;
10008
10009 impl ::fidl_next::Method for Export {
10010 const ORDINAL: u64 = 226159162093533951;
10011 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10012 ::fidl_next::protocol::Flexibility::Flexible;
10013
10014 type Protocol = crate::CapabilityStore;
10015
10016 type Request = crate::wire::CapabilityStoreExportRequest;
10017 }
10018
10019 impl ::fidl_next::TwoWayMethod for Export {
10020 type Response = ::fidl_next::wire::Result<
10021 'static,
10022 crate::wire::CapabilityStoreExportResponse<'static>,
10023 crate::wire::CapabilityStoreError,
10024 >;
10025 }
10026
10027 impl<___R> ::fidl_next::Respond<___R> for Export {
10028 type Output = ::core::result::Result<
10029 crate::generic::CapabilityStoreExportResponse<___R>,
10030 ::fidl_next::never::Never,
10031 >;
10032
10033 fn respond(response: ___R) -> Self::Output {
10034 ::core::result::Result::Ok(crate::generic::CapabilityStoreExportResponse {
10035 capability: response,
10036 })
10037 }
10038 }
10039
10040 impl<___R> ::fidl_next::RespondErr<___R> for Export {
10041 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10042
10043 fn respond_err(response: ___R) -> Self::Output {
10044 ::core::result::Result::Err(response)
10045 }
10046 }
10047
10048 pub struct Import;
10049
10050 impl ::fidl_next::Method for Import {
10051 const ORDINAL: u64 = 2276030276116435867;
10052 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10053 ::fidl_next::protocol::Flexibility::Flexible;
10054
10055 type Protocol = crate::CapabilityStore;
10056
10057 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
10058 }
10059
10060 impl ::fidl_next::TwoWayMethod for Import {
10061 type Response = ::fidl_next::wire::Result<
10062 'static,
10063 crate::wire::CapabilityStoreImportResponse,
10064 crate::wire::CapabilityStoreError,
10065 >;
10066 }
10067
10068 impl<___R> ::fidl_next::Respond<___R> for Import {
10069 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10070
10071 fn respond(response: ___R) -> Self::Output {
10072 ::core::result::Result::Ok(response)
10073 }
10074 }
10075
10076 impl<___R> ::fidl_next::RespondErr<___R> for Import {
10077 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10078
10079 fn respond_err(response: ___R) -> Self::Output {
10080 ::core::result::Result::Err(response)
10081 }
10082 }
10083
10084 pub struct ConnectorCreate;
10085
10086 impl ::fidl_next::Method for ConnectorCreate {
10087 const ORDINAL: u64 = 2979461408102095909;
10088 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10089 ::fidl_next::protocol::Flexibility::Flexible;
10090
10091 type Protocol = crate::CapabilityStore;
10092
10093 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
10094 }
10095
10096 impl ::fidl_next::TwoWayMethod for ConnectorCreate {
10097 type Response = ::fidl_next::wire::Result<
10098 'static,
10099 crate::wire::CapabilityStoreConnectorCreateResponse,
10100 crate::wire::CapabilityStoreError,
10101 >;
10102 }
10103
10104 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
10105 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10106
10107 fn respond(response: ___R) -> Self::Output {
10108 ::core::result::Result::Ok(response)
10109 }
10110 }
10111
10112 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
10113 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10114
10115 fn respond_err(response: ___R) -> Self::Output {
10116 ::core::result::Result::Err(response)
10117 }
10118 }
10119
10120 pub struct ConnectorOpen;
10121
10122 impl ::fidl_next::Method for ConnectorOpen {
10123 const ORDINAL: u64 = 6016362336453278623;
10124 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10125 ::fidl_next::protocol::Flexibility::Flexible;
10126
10127 type Protocol = crate::CapabilityStore;
10128
10129 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
10130 }
10131
10132 impl ::fidl_next::TwoWayMethod for ConnectorOpen {
10133 type Response = ::fidl_next::wire::Result<
10134 'static,
10135 crate::wire::CapabilityStoreConnectorOpenResponse,
10136 crate::wire::CapabilityStoreError,
10137 >;
10138 }
10139
10140 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
10141 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10142
10143 fn respond(response: ___R) -> Self::Output {
10144 ::core::result::Result::Ok(response)
10145 }
10146 }
10147
10148 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
10149 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10150
10151 fn respond_err(response: ___R) -> Self::Output {
10152 ::core::result::Result::Err(response)
10153 }
10154 }
10155
10156 pub struct DirConnectorCreate;
10157
10158 impl ::fidl_next::Method for DirConnectorCreate {
10159 const ORDINAL: u64 = 1756747594275428795;
10160 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10161 ::fidl_next::protocol::Flexibility::Flexible;
10162
10163 type Protocol = crate::CapabilityStore;
10164
10165 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
10166 }
10167
10168 impl ::fidl_next::TwoWayMethod for DirConnectorCreate {
10169 type Response = ::fidl_next::wire::Result<
10170 'static,
10171 crate::wire::CapabilityStoreDirConnectorCreateResponse,
10172 crate::wire::CapabilityStoreError,
10173 >;
10174 }
10175
10176 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
10177 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10178
10179 fn respond(response: ___R) -> Self::Output {
10180 ::core::result::Result::Ok(response)
10181 }
10182 }
10183
10184 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
10185 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10186
10187 fn respond_err(response: ___R) -> Self::Output {
10188 ::core::result::Result::Err(response)
10189 }
10190 }
10191
10192 pub struct DirConnectorOpen;
10193
10194 impl ::fidl_next::Method for DirConnectorOpen {
10195 const ORDINAL: u64 = 6219704004220369153;
10196 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10197 ::fidl_next::protocol::Flexibility::Flexible;
10198
10199 type Protocol = crate::CapabilityStore;
10200
10201 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>;
10202 }
10203
10204 impl ::fidl_next::TwoWayMethod for DirConnectorOpen {
10205 type Response = ::fidl_next::wire::Result<
10206 'static,
10207 crate::wire::CapabilityStoreDirConnectorOpenResponse,
10208 crate::wire::CapabilityStoreError,
10209 >;
10210 }
10211
10212 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
10213 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10214
10215 fn respond(response: ___R) -> Self::Output {
10216 ::core::result::Result::Ok(response)
10217 }
10218 }
10219
10220 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
10221 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10222
10223 fn respond_err(response: ___R) -> Self::Output {
10224 ::core::result::Result::Err(response)
10225 }
10226 }
10227
10228 pub struct DictionaryCreate;
10229
10230 impl ::fidl_next::Method for DictionaryCreate {
10231 const ORDINAL: u64 = 7608770958894948499;
10232 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10233 ::fidl_next::protocol::Flexibility::Flexible;
10234
10235 type Protocol = crate::CapabilityStore;
10236
10237 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
10238 }
10239
10240 impl ::fidl_next::TwoWayMethod for DictionaryCreate {
10241 type Response = ::fidl_next::wire::Result<
10242 'static,
10243 crate::wire::CapabilityStoreDictionaryCreateResponse,
10244 crate::wire::CapabilityStoreError,
10245 >;
10246 }
10247
10248 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
10249 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10250
10251 fn respond(response: ___R) -> Self::Output {
10252 ::core::result::Result::Ok(response)
10253 }
10254 }
10255
10256 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
10257 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10258
10259 fn respond_err(response: ___R) -> Self::Output {
10260 ::core::result::Result::Err(response)
10261 }
10262 }
10263
10264 pub struct DictionaryLegacyImport;
10265
10266 impl ::fidl_next::Method for DictionaryLegacyImport {
10267 const ORDINAL: u64 = 8285893703432012383;
10268 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10269 ::fidl_next::protocol::Flexibility::Flexible;
10270
10271 type Protocol = crate::CapabilityStore;
10272
10273 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
10274 }
10275
10276 impl ::fidl_next::TwoWayMethod for DictionaryLegacyImport {
10277 type Response = ::fidl_next::wire::Result<
10278 'static,
10279 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
10280 crate::wire::CapabilityStoreError,
10281 >;
10282 }
10283
10284 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
10285 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10286
10287 fn respond(response: ___R) -> Self::Output {
10288 ::core::result::Result::Ok(response)
10289 }
10290 }
10291
10292 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
10293 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10294
10295 fn respond_err(response: ___R) -> Self::Output {
10296 ::core::result::Result::Err(response)
10297 }
10298 }
10299
10300 pub struct DictionaryLegacyExport;
10301
10302 impl ::fidl_next::Method for DictionaryLegacyExport {
10303 const ORDINAL: u64 = 4647175832683306445;
10304 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10305 ::fidl_next::protocol::Flexibility::Flexible;
10306
10307 type Protocol = crate::CapabilityStore;
10308
10309 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
10310 }
10311
10312 impl ::fidl_next::TwoWayMethod for DictionaryLegacyExport {
10313 type Response = ::fidl_next::wire::Result<
10314 'static,
10315 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
10316 crate::wire::CapabilityStoreError,
10317 >;
10318 }
10319
10320 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
10321 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10322
10323 fn respond(response: ___R) -> Self::Output {
10324 ::core::result::Result::Ok(response)
10325 }
10326 }
10327
10328 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
10329 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10330
10331 fn respond_err(response: ___R) -> Self::Output {
10332 ::core::result::Result::Err(response)
10333 }
10334 }
10335
10336 pub struct DictionaryInsert;
10337
10338 impl ::fidl_next::Method for DictionaryInsert {
10339 const ORDINAL: u64 = 8575443262986538023;
10340 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10341 ::fidl_next::protocol::Flexibility::Flexible;
10342
10343 type Protocol = crate::CapabilityStore;
10344
10345 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
10346 }
10347
10348 impl ::fidl_next::TwoWayMethod for DictionaryInsert {
10349 type Response = ::fidl_next::wire::Result<
10350 'static,
10351 crate::wire::CapabilityStoreDictionaryInsertResponse,
10352 crate::wire::CapabilityStoreError,
10353 >;
10354 }
10355
10356 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
10357 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10358
10359 fn respond(response: ___R) -> Self::Output {
10360 ::core::result::Result::Ok(response)
10361 }
10362 }
10363
10364 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
10365 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10366
10367 fn respond_err(response: ___R) -> Self::Output {
10368 ::core::result::Result::Err(response)
10369 }
10370 }
10371
10372 pub struct DictionaryGet;
10373
10374 impl ::fidl_next::Method for DictionaryGet {
10375 const ORDINAL: u64 = 5592951026866236882;
10376 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10377 ::fidl_next::protocol::Flexibility::Flexible;
10378
10379 type Protocol = crate::CapabilityStore;
10380
10381 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
10382 }
10383
10384 impl ::fidl_next::TwoWayMethod for DictionaryGet {
10385 type Response = ::fidl_next::wire::Result<
10386 'static,
10387 crate::wire::CapabilityStoreDictionaryGetResponse,
10388 crate::wire::CapabilityStoreError,
10389 >;
10390 }
10391
10392 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
10393 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10394
10395 fn respond(response: ___R) -> Self::Output {
10396 ::core::result::Result::Ok(response)
10397 }
10398 }
10399
10400 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
10401 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10402
10403 fn respond_err(response: ___R) -> Self::Output {
10404 ::core::result::Result::Err(response)
10405 }
10406 }
10407
10408 pub struct DictionaryRemove;
10409
10410 impl ::fidl_next::Method for DictionaryRemove {
10411 const ORDINAL: u64 = 343892214579320051;
10412 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10413 ::fidl_next::protocol::Flexibility::Flexible;
10414
10415 type Protocol = crate::CapabilityStore;
10416
10417 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
10418 }
10419
10420 impl ::fidl_next::TwoWayMethod for DictionaryRemove {
10421 type Response = ::fidl_next::wire::Result<
10422 'static,
10423 crate::wire::CapabilityStoreDictionaryRemoveResponse,
10424 crate::wire::CapabilityStoreError,
10425 >;
10426 }
10427
10428 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
10429 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10430
10431 fn respond(response: ___R) -> Self::Output {
10432 ::core::result::Result::Ok(response)
10433 }
10434 }
10435
10436 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
10437 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10438
10439 fn respond_err(response: ___R) -> Self::Output {
10440 ::core::result::Result::Err(response)
10441 }
10442 }
10443
10444 pub struct DictionaryCopy;
10445
10446 impl ::fidl_next::Method for DictionaryCopy {
10447 const ORDINAL: u64 = 3977783339739362383;
10448 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10449 ::fidl_next::protocol::Flexibility::Flexible;
10450
10451 type Protocol = crate::CapabilityStore;
10452
10453 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
10454 }
10455
10456 impl ::fidl_next::TwoWayMethod for DictionaryCopy {
10457 type Response = ::fidl_next::wire::Result<
10458 'static,
10459 crate::wire::CapabilityStoreDictionaryCopyResponse,
10460 crate::wire::CapabilityStoreError,
10461 >;
10462 }
10463
10464 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
10465 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10466
10467 fn respond(response: ___R) -> Self::Output {
10468 ::core::result::Result::Ok(response)
10469 }
10470 }
10471
10472 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
10473 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10474
10475 fn respond_err(response: ___R) -> Self::Output {
10476 ::core::result::Result::Err(response)
10477 }
10478 }
10479
10480 pub struct DictionaryKeys;
10481
10482 impl ::fidl_next::Method for DictionaryKeys {
10483 const ORDINAL: u64 = 597577248872787102;
10484 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10485 ::fidl_next::protocol::Flexibility::Flexible;
10486
10487 type Protocol = crate::CapabilityStore;
10488
10489 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
10490 }
10491
10492 impl ::fidl_next::TwoWayMethod for DictionaryKeys {
10493 type Response = ::fidl_next::wire::Result<
10494 'static,
10495 crate::wire::CapabilityStoreDictionaryKeysResponse,
10496 crate::wire::CapabilityStoreError,
10497 >;
10498 }
10499
10500 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
10501 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10502
10503 fn respond(response: ___R) -> Self::Output {
10504 ::core::result::Result::Ok(response)
10505 }
10506 }
10507
10508 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
10509 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10510
10511 fn respond_err(response: ___R) -> Self::Output {
10512 ::core::result::Result::Err(response)
10513 }
10514 }
10515
10516 pub struct DictionaryEnumerate;
10517
10518 impl ::fidl_next::Method for DictionaryEnumerate {
10519 const ORDINAL: u64 = 964467096271472193;
10520 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10521 ::fidl_next::protocol::Flexibility::Flexible;
10522
10523 type Protocol = crate::CapabilityStore;
10524
10525 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
10526 }
10527
10528 impl ::fidl_next::TwoWayMethod for DictionaryEnumerate {
10529 type Response = ::fidl_next::wire::Result<
10530 'static,
10531 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
10532 crate::wire::CapabilityStoreError,
10533 >;
10534 }
10535
10536 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
10537 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10538
10539 fn respond(response: ___R) -> Self::Output {
10540 ::core::result::Result::Ok(response)
10541 }
10542 }
10543
10544 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
10545 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10546
10547 fn respond_err(response: ___R) -> Self::Output {
10548 ::core::result::Result::Err(response)
10549 }
10550 }
10551
10552 pub struct DictionaryDrain;
10553
10554 impl ::fidl_next::Method for DictionaryDrain {
10555 const ORDINAL: u64 = 2928364469569621208;
10556 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10557 ::fidl_next::protocol::Flexibility::Flexible;
10558
10559 type Protocol = crate::CapabilityStore;
10560
10561 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
10562 }
10563
10564 impl ::fidl_next::TwoWayMethod for DictionaryDrain {
10565 type Response = ::fidl_next::wire::Result<
10566 'static,
10567 crate::wire::CapabilityStoreDictionaryDrainResponse,
10568 crate::wire::CapabilityStoreError,
10569 >;
10570 }
10571
10572 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
10573 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10574
10575 fn respond(response: ___R) -> Self::Output {
10576 ::core::result::Result::Ok(response)
10577 }
10578 }
10579
10580 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
10581 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10582
10583 fn respond_err(response: ___R) -> Self::Output {
10584 ::core::result::Result::Err(response)
10585 }
10586 }
10587
10588 pub struct CreateServiceAggregate;
10589
10590 impl ::fidl_next::Method for CreateServiceAggregate {
10591 const ORDINAL: u64 = 5009147843253209178;
10592 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10593 ::fidl_next::protocol::Flexibility::Flexible;
10594
10595 type Protocol = crate::CapabilityStore;
10596
10597 type Request = crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>;
10598 }
10599
10600 impl ::fidl_next::TwoWayMethod for CreateServiceAggregate {
10601 type Response = ::fidl_next::wire::Result<
10602 'static,
10603 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
10604 crate::wire::CapabilityStoreError,
10605 >;
10606 }
10607
10608 impl<___R> ::fidl_next::Respond<___R> for CreateServiceAggregate {
10609 type Output = ::core::result::Result<
10610 crate::generic::CapabilityStoreCreateServiceAggregateResponse<___R>,
10611 ::fidl_next::never::Never,
10612 >;
10613
10614 fn respond(response: ___R) -> Self::Output {
10615 ::core::result::Result::Ok(
10616 crate::generic::CapabilityStoreCreateServiceAggregateResponse {
10617 aggregate_dir_connector: response,
10618 },
10619 )
10620 }
10621 }
10622
10623 impl<___R> ::fidl_next::RespondErr<___R> for CreateServiceAggregate {
10624 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10625
10626 fn respond_err(response: ___R) -> Self::Output {
10627 ::core::result::Result::Err(response)
10628 }
10629 }
10630
10631 mod ___detail {
10632 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
10633 where
10634 ___T: ::fidl_next::Transport,
10635 {
10636 type Client = CapabilityStoreClient<___T>;
10637 type Server = CapabilityStoreServer<___T>;
10638 }
10639
10640 #[repr(transparent)]
10642 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
10643 #[allow(dead_code)]
10644 client: ::fidl_next::protocol::Client<___T>,
10645 }
10646
10647 impl<___T> CapabilityStoreClient<___T>
10648 where
10649 ___T: ::fidl_next::Transport,
10650 {
10651 #[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"]
10652 pub fn duplicate(
10653 &self,
10654
10655 id: impl ::fidl_next::Encode<
10656 ::fidl_next::wire::Uint64,
10657 <___T as ::fidl_next::Transport>::SendBuffer,
10658 >,
10659
10660 dest_id: impl ::fidl_next::Encode<
10661 ::fidl_next::wire::Uint64,
10662 <___T as ::fidl_next::Transport>::SendBuffer,
10663 >,
10664 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
10665 where
10666 <___T as ::fidl_next::Transport>::SendBuffer:
10667 ::fidl_next::encoder::InternalHandleEncoder,
10668 {
10669 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
10670 }
10671
10672 #[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"]
10673 pub fn duplicate_with<___R>(
10674 &self,
10675 request: ___R,
10676 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
10677 where
10678 ___R: ::fidl_next::Encode<
10679 crate::wire::CapabilityStoreDuplicateRequest,
10680 <___T as ::fidl_next::Transport>::SendBuffer,
10681 >,
10682 {
10683 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10684 6727592627741008260,
10685 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
10686 request,
10687 ))
10688 }
10689
10690 #[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"]
10691 pub fn drop(
10692 &self,
10693
10694 id: impl ::fidl_next::Encode<
10695 ::fidl_next::wire::Uint64,
10696 <___T as ::fidl_next::Transport>::SendBuffer,
10697 >,
10698 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
10699 where
10700 <___T as ::fidl_next::Transport>::SendBuffer:
10701 ::fidl_next::encoder::InternalHandleEncoder,
10702 {
10703 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
10704 }
10705
10706 #[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"]
10707 pub fn drop_with<___R>(
10708 &self,
10709 request: ___R,
10710 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
10711 where
10712 ___R: ::fidl_next::Encode<
10713 crate::wire::CapabilityStoreDropRequest,
10714 <___T as ::fidl_next::Transport>::SendBuffer,
10715 >,
10716 {
10717 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10718 753328233834620249,
10719 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
10720 request,
10721 ))
10722 }
10723
10724 #[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"]
10725 pub fn export(
10726 &self,
10727
10728 id: impl ::fidl_next::Encode<
10729 ::fidl_next::wire::Uint64,
10730 <___T as ::fidl_next::Transport>::SendBuffer,
10731 >,
10732 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
10733 where
10734 <___T as ::fidl_next::Transport>::SendBuffer:
10735 ::fidl_next::encoder::InternalHandleEncoder,
10736 {
10737 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
10738 }
10739
10740 #[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"]
10741 pub fn export_with<___R>(
10742 &self,
10743 request: ___R,
10744 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
10745 where
10746 ___R: ::fidl_next::Encode<
10747 crate::wire::CapabilityStoreExportRequest,
10748 <___T as ::fidl_next::Transport>::SendBuffer,
10749 >,
10750 {
10751 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10752 226159162093533951,
10753 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
10754 request,
10755 ))
10756 }
10757
10758 #[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"]
10759 pub fn import(
10760 &self,
10761
10762 id: impl ::fidl_next::Encode<
10763 ::fidl_next::wire::Uint64,
10764 <___T as ::fidl_next::Transport>::SendBuffer,
10765 >,
10766
10767 capability: impl ::fidl_next::Encode<
10768 crate::wire::Capability<'static>,
10769 <___T as ::fidl_next::Transport>::SendBuffer,
10770 >,
10771 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
10772 where
10773 <___T as ::fidl_next::Transport>::SendBuffer:
10774 ::fidl_next::encoder::InternalHandleEncoder,
10775 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10776 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10777 {
10778 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
10779 }
10780
10781 #[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"]
10782 pub fn import_with<___R>(
10783 &self,
10784 request: ___R,
10785 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
10786 where
10787 ___R: ::fidl_next::Encode<
10788 crate::wire::CapabilityStoreImportRequest<'static>,
10789 <___T as ::fidl_next::Transport>::SendBuffer,
10790 >,
10791 {
10792 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10793 2276030276116435867,
10794 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
10795 request,
10796 ))
10797 }
10798
10799 #[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"]
10800 pub fn connector_create(
10801 &self,
10802
10803 id: impl ::fidl_next::Encode<
10804 ::fidl_next::wire::Uint64,
10805 <___T as ::fidl_next::Transport>::SendBuffer,
10806 >,
10807
10808 receiver: impl ::fidl_next::Encode<
10809 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
10810 <___T as ::fidl_next::Transport>::SendBuffer,
10811 >,
10812 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
10813 where
10814 <___T as ::fidl_next::Transport>::SendBuffer:
10815 ::fidl_next::encoder::InternalHandleEncoder,
10816 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10817 {
10818 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
10819 id,
10820
10821 receiver,
10822 })
10823 }
10824
10825 #[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"]
10826 pub fn connector_create_with<___R>(
10827 &self,
10828 request: ___R,
10829 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
10830 where
10831 ___R: ::fidl_next::Encode<
10832 crate::wire::CapabilityStoreConnectorCreateRequest,
10833 <___T as ::fidl_next::Transport>::SendBuffer,
10834 >,
10835 {
10836 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10837 2979461408102095909,
10838 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
10839 request,
10840 ))
10841 }
10842
10843 #[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"]
10844 pub fn connector_open(
10845 &self,
10846
10847 id: impl ::fidl_next::Encode<
10848 ::fidl_next::wire::Uint64,
10849 <___T as ::fidl_next::Transport>::SendBuffer,
10850 >,
10851
10852 server_end: impl ::fidl_next::Encode<
10853 ::fidl_next::wire::fuchsia::Channel,
10854 <___T as ::fidl_next::Transport>::SendBuffer,
10855 >,
10856 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
10857 where
10858 <___T as ::fidl_next::Transport>::SendBuffer:
10859 ::fidl_next::encoder::InternalHandleEncoder,
10860 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10861 {
10862 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
10863 id,
10864
10865 server_end,
10866 })
10867 }
10868
10869 #[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"]
10870 pub fn connector_open_with<___R>(
10871 &self,
10872 request: ___R,
10873 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
10874 where
10875 ___R: ::fidl_next::Encode<
10876 crate::wire::CapabilityStoreConnectorOpenRequest,
10877 <___T as ::fidl_next::Transport>::SendBuffer,
10878 >,
10879 {
10880 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10881 6016362336453278623,
10882 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
10883 request,
10884 ))
10885 }
10886
10887 #[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"]
10888 pub fn dir_connector_create(
10889 &self,
10890
10891 id: impl ::fidl_next::Encode<
10892 ::fidl_next::wire::Uint64,
10893 <___T as ::fidl_next::Transport>::SendBuffer,
10894 >,
10895
10896 receiver: impl ::fidl_next::Encode<
10897 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
10898 <___T as ::fidl_next::Transport>::SendBuffer,
10899 >,
10900 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
10901 where
10902 <___T as ::fidl_next::Transport>::SendBuffer:
10903 ::fidl_next::encoder::InternalHandleEncoder,
10904 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10905 {
10906 self.dir_connector_create_with(
10907 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
10908 )
10909 }
10910
10911 #[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"]
10912 pub fn dir_connector_create_with<___R>(
10913 &self,
10914 request: ___R,
10915 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
10916 where
10917 ___R: ::fidl_next::Encode<
10918 crate::wire::CapabilityStoreDirConnectorCreateRequest,
10919 <___T as ::fidl_next::Transport>::SendBuffer,
10920 >,
10921 {
10922 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10923 1756747594275428795,
10924 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
10925 request,
10926 ))
10927 }
10928
10929 #[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"]
10930 pub fn dir_connector_open_with<___R>(
10931 &self,
10932 request: ___R,
10933 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
10934 where
10935 ___R: ::fidl_next::Encode<
10936 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
10937 <___T as ::fidl_next::Transport>::SendBuffer,
10938 >,
10939 {
10940 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10941 6219704004220369153,
10942 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
10943 request,
10944 ))
10945 }
10946
10947 #[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"]
10948 pub fn dictionary_create(
10949 &self,
10950
10951 id: impl ::fidl_next::Encode<
10952 ::fidl_next::wire::Uint64,
10953 <___T as ::fidl_next::Transport>::SendBuffer,
10954 >,
10955 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
10956 where
10957 <___T as ::fidl_next::Transport>::SendBuffer:
10958 ::fidl_next::encoder::InternalHandleEncoder,
10959 {
10960 self.dictionary_create_with(
10961 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
10962 )
10963 }
10964
10965 #[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"]
10966 pub fn dictionary_create_with<___R>(
10967 &self,
10968 request: ___R,
10969 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
10970 where
10971 ___R: ::fidl_next::Encode<
10972 crate::wire::CapabilityStoreDictionaryCreateRequest,
10973 <___T as ::fidl_next::Transport>::SendBuffer,
10974 >,
10975 {
10976 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10977 7608770958894948499,
10978 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
10979 request,
10980 ))
10981 }
10982
10983 #[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"]
10984 pub fn dictionary_legacy_import(
10985 &self,
10986
10987 id: impl ::fidl_next::Encode<
10988 ::fidl_next::wire::Uint64,
10989 <___T as ::fidl_next::Transport>::SendBuffer,
10990 >,
10991
10992 client_end: impl ::fidl_next::Encode<
10993 ::fidl_next::wire::fuchsia::Channel,
10994 <___T as ::fidl_next::Transport>::SendBuffer,
10995 >,
10996 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
10997 where
10998 <___T as ::fidl_next::Transport>::SendBuffer:
10999 ::fidl_next::encoder::InternalHandleEncoder,
11000 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11001 {
11002 self.dictionary_legacy_import_with(
11003 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
11004 )
11005 }
11006
11007 #[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"]
11008 pub fn dictionary_legacy_import_with<___R>(
11009 &self,
11010 request: ___R,
11011 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
11012 where
11013 ___R: ::fidl_next::Encode<
11014 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
11015 <___T as ::fidl_next::Transport>::SendBuffer,
11016 >,
11017 {
11018 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11019 8285893703432012383,
11020 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
11021 request,
11022 ))
11023 }
11024
11025 #[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"]
11026 pub fn dictionary_legacy_export(
11027 &self,
11028
11029 id: impl ::fidl_next::Encode<
11030 ::fidl_next::wire::Uint64,
11031 <___T as ::fidl_next::Transport>::SendBuffer,
11032 >,
11033
11034 server_end: impl ::fidl_next::Encode<
11035 ::fidl_next::wire::fuchsia::Channel,
11036 <___T as ::fidl_next::Transport>::SendBuffer,
11037 >,
11038 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
11039 where
11040 <___T as ::fidl_next::Transport>::SendBuffer:
11041 ::fidl_next::encoder::InternalHandleEncoder,
11042 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11043 {
11044 self.dictionary_legacy_export_with(
11045 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
11046 )
11047 }
11048
11049 #[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"]
11050 pub fn dictionary_legacy_export_with<___R>(
11051 &self,
11052 request: ___R,
11053 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
11054 where
11055 ___R: ::fidl_next::Encode<
11056 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
11057 <___T as ::fidl_next::Transport>::SendBuffer,
11058 >,
11059 {
11060 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11061 4647175832683306445,
11062 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
11063 request,
11064 ))
11065 }
11066
11067 #[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"]
11068 pub fn dictionary_insert(
11069 &self,
11070
11071 id: impl ::fidl_next::Encode<
11072 ::fidl_next::wire::Uint64,
11073 <___T as ::fidl_next::Transport>::SendBuffer,
11074 >,
11075
11076 item: impl ::fidl_next::Encode<
11077 crate::wire::DictionaryItem<'static>,
11078 <___T as ::fidl_next::Transport>::SendBuffer,
11079 >,
11080 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
11081 where
11082 <___T as ::fidl_next::Transport>::SendBuffer:
11083 ::fidl_next::encoder::InternalHandleEncoder,
11084 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11085 {
11086 self.dictionary_insert_with(
11087 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
11088 )
11089 }
11090
11091 #[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"]
11092 pub fn dictionary_insert_with<___R>(
11093 &self,
11094 request: ___R,
11095 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
11096 where
11097 ___R: ::fidl_next::Encode<
11098 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
11099 <___T as ::fidl_next::Transport>::SendBuffer,
11100 >,
11101 {
11102 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11103 8575443262986538023,
11104 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
11105 request,
11106 ))
11107 }
11108
11109 #[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"]
11110 pub fn dictionary_get(
11111 &self,
11112
11113 id: impl ::fidl_next::Encode<
11114 ::fidl_next::wire::Uint64,
11115 <___T as ::fidl_next::Transport>::SendBuffer,
11116 >,
11117
11118 key: impl ::fidl_next::Encode<
11119 ::fidl_next::wire::String<'static>,
11120 <___T as ::fidl_next::Transport>::SendBuffer,
11121 >,
11122
11123 dest_id: impl ::fidl_next::Encode<
11124 ::fidl_next::wire::Uint64,
11125 <___T as ::fidl_next::Transport>::SendBuffer,
11126 >,
11127 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
11128 where
11129 <___T as ::fidl_next::Transport>::SendBuffer:
11130 ::fidl_next::encoder::InternalHandleEncoder,
11131 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11132 {
11133 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
11134 id,
11135
11136 key,
11137
11138 dest_id,
11139 })
11140 }
11141
11142 #[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"]
11143 pub fn dictionary_get_with<___R>(
11144 &self,
11145 request: ___R,
11146 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
11147 where
11148 ___R: ::fidl_next::Encode<
11149 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
11150 <___T as ::fidl_next::Transport>::SendBuffer,
11151 >,
11152 {
11153 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11154 5592951026866236882,
11155 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
11156 request,
11157 ))
11158 }
11159
11160 #[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"]
11161 pub fn dictionary_remove(
11162 &self,
11163
11164 id: impl ::fidl_next::Encode<
11165 ::fidl_next::wire::Uint64,
11166 <___T as ::fidl_next::Transport>::SendBuffer,
11167 >,
11168
11169 key: impl ::fidl_next::Encode<
11170 ::fidl_next::wire::String<'static>,
11171 <___T as ::fidl_next::Transport>::SendBuffer,
11172 >,
11173
11174 dest_id: impl ::fidl_next::Encode<
11175 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
11176 <___T as ::fidl_next::Transport>::SendBuffer,
11177 >,
11178 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
11179 where
11180 <___T as ::fidl_next::Transport>::SendBuffer:
11181 ::fidl_next::encoder::InternalHandleEncoder,
11182 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11183 {
11184 self.dictionary_remove_with(
11185 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
11186 )
11187 }
11188
11189 #[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"]
11190 pub fn dictionary_remove_with<___R>(
11191 &self,
11192 request: ___R,
11193 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
11194 where
11195 ___R: ::fidl_next::Encode<
11196 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
11197 <___T as ::fidl_next::Transport>::SendBuffer,
11198 >,
11199 {
11200 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11201 343892214579320051,
11202 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
11203 request,
11204 ))
11205 }
11206
11207 #[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"]
11208 pub fn dictionary_copy(
11209 &self,
11210
11211 id: impl ::fidl_next::Encode<
11212 ::fidl_next::wire::Uint64,
11213 <___T as ::fidl_next::Transport>::SendBuffer,
11214 >,
11215
11216 dest_id: impl ::fidl_next::Encode<
11217 ::fidl_next::wire::Uint64,
11218 <___T as ::fidl_next::Transport>::SendBuffer,
11219 >,
11220 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
11221 where
11222 <___T as ::fidl_next::Transport>::SendBuffer:
11223 ::fidl_next::encoder::InternalHandleEncoder,
11224 {
11225 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
11226 id,
11227
11228 dest_id,
11229 })
11230 }
11231
11232 #[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"]
11233 pub fn dictionary_copy_with<___R>(
11234 &self,
11235 request: ___R,
11236 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
11237 where
11238 ___R: ::fidl_next::Encode<
11239 crate::wire::CapabilityStoreDictionaryCopyRequest,
11240 <___T as ::fidl_next::Transport>::SendBuffer,
11241 >,
11242 {
11243 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11244 3977783339739362383,
11245 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
11246 request,
11247 ))
11248 }
11249
11250 #[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"]
11251 pub fn dictionary_keys(
11252 &self,
11253
11254 id: impl ::fidl_next::Encode<
11255 ::fidl_next::wire::Uint64,
11256 <___T as ::fidl_next::Transport>::SendBuffer,
11257 >,
11258
11259 iterator: impl ::fidl_next::Encode<
11260 ::fidl_next::ServerEnd<
11261 crate::DictionaryKeysIterator,
11262 ::fidl_next::wire::fuchsia::Channel,
11263 >,
11264 <___T as ::fidl_next::Transport>::SendBuffer,
11265 >,
11266 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
11267 where
11268 <___T as ::fidl_next::Transport>::SendBuffer:
11269 ::fidl_next::encoder::InternalHandleEncoder,
11270 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11271 {
11272 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
11273 id,
11274
11275 iterator,
11276 })
11277 }
11278
11279 #[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"]
11280 pub fn dictionary_keys_with<___R>(
11281 &self,
11282 request: ___R,
11283 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
11284 where
11285 ___R: ::fidl_next::Encode<
11286 crate::wire::CapabilityStoreDictionaryKeysRequest,
11287 <___T as ::fidl_next::Transport>::SendBuffer,
11288 >,
11289 {
11290 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11291 597577248872787102,
11292 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
11293 request,
11294 ))
11295 }
11296
11297 #[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"]
11298 pub fn dictionary_enumerate(
11299 &self,
11300
11301 id: impl ::fidl_next::Encode<
11302 ::fidl_next::wire::Uint64,
11303 <___T as ::fidl_next::Transport>::SendBuffer,
11304 >,
11305
11306 iterator: impl ::fidl_next::Encode<
11307 ::fidl_next::ServerEnd<
11308 crate::DictionaryEnumerateIterator,
11309 ::fidl_next::wire::fuchsia::Channel,
11310 >,
11311 <___T as ::fidl_next::Transport>::SendBuffer,
11312 >,
11313 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
11314 where
11315 <___T as ::fidl_next::Transport>::SendBuffer:
11316 ::fidl_next::encoder::InternalHandleEncoder,
11317 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11318 {
11319 self.dictionary_enumerate_with(
11320 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
11321 )
11322 }
11323
11324 #[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"]
11325 pub fn dictionary_enumerate_with<___R>(
11326 &self,
11327 request: ___R,
11328 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
11329 where
11330 ___R: ::fidl_next::Encode<
11331 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
11332 <___T as ::fidl_next::Transport>::SendBuffer,
11333 >,
11334 {
11335 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11336 964467096271472193,
11337 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
11338 request,
11339 ))
11340 }
11341
11342 #[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"]
11343 pub fn dictionary_drain(
11344 &self,
11345
11346 id: impl ::fidl_next::Encode<
11347 ::fidl_next::wire::Uint64,
11348 <___T as ::fidl_next::Transport>::SendBuffer,
11349 >,
11350
11351 iterator: impl ::fidl_next::Encode<
11352 ::fidl_next::ServerEnd<
11353 crate::DictionaryDrainIterator,
11354 ::fidl_next::wire::fuchsia::OptionalChannel,
11355 >,
11356 <___T as ::fidl_next::Transport>::SendBuffer,
11357 >,
11358 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
11359 where
11360 <___T as ::fidl_next::Transport>::SendBuffer:
11361 ::fidl_next::encoder::InternalHandleEncoder,
11362 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11363 {
11364 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
11365 id,
11366
11367 iterator,
11368 })
11369 }
11370
11371 #[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"]
11372 pub fn dictionary_drain_with<___R>(
11373 &self,
11374 request: ___R,
11375 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
11376 where
11377 ___R: ::fidl_next::Encode<
11378 crate::wire::CapabilityStoreDictionaryDrainRequest,
11379 <___T as ::fidl_next::Transport>::SendBuffer,
11380 >,
11381 {
11382 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11383 2928364469569621208,
11384 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
11385 request,
11386 ))
11387 }
11388
11389 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
11390 pub fn create_service_aggregate(
11391 &self,
11392
11393 sources: impl ::fidl_next::Encode<
11394 ::fidl_next::wire::Vector<'static, crate::wire::AggregateSource<'static>>,
11395 <___T as ::fidl_next::Transport>::SendBuffer,
11396 >,
11397 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
11398 where
11399 <___T as ::fidl_next::Transport>::SendBuffer:
11400 ::fidl_next::encoder::InternalHandleEncoder,
11401 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11402 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11403 {
11404 self.create_service_aggregate_with(
11405 crate::generic::CapabilityStoreCreateServiceAggregateRequest { sources },
11406 )
11407 }
11408
11409 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
11410 pub fn create_service_aggregate_with<___R>(
11411 &self,
11412 request: ___R,
11413 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
11414 where
11415 ___R: ::fidl_next::Encode<
11416 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
11417 <___T as ::fidl_next::Transport>::SendBuffer,
11418 >,
11419 {
11420 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11421 5009147843253209178,
11422 <super::CreateServiceAggregate as ::fidl_next::Method>::FLEXIBILITY,
11423 request,
11424 ))
11425 }
11426 }
11427
11428 #[repr(transparent)]
11430 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
11431 server: ::fidl_next::protocol::Server<___T>,
11432 }
11433
11434 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
11435 }
11436}
11437
11438#[diagnostic::on_unimplemented(
11439 note = "If {Self} implements the non-local CapabilityStoreClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11440)]
11441
11442pub trait CapabilityStoreLocalClientHandler<
11446 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11447 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11448>
11449{
11450 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11451 ::core::future::ready(())
11452 }
11453}
11454
11455impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for CapabilityStore
11456where
11457 ___H: CapabilityStoreLocalClientHandler<___T>,
11458 ___T: ::fidl_next::Transport,
11459{
11460 async fn on_event(
11461 handler: &mut ___H,
11462 mut message: ::fidl_next::Message<___T>,
11463 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11464 match *message.header().ordinal {
11465 ordinal => {
11466 handler.on_unknown_interaction(ordinal).await;
11467 if ::core::matches!(
11468 message.header().flexibility(),
11469 ::fidl_next::protocol::Flexibility::Strict
11470 ) {
11471 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11472 } else {
11473 Ok(())
11474 }
11475 }
11476 }
11477 }
11478}
11479
11480#[diagnostic::on_unimplemented(
11481 note = "If {Self} implements the non-local CapabilityStoreServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11482)]
11483
11484pub trait CapabilityStoreLocalServerHandler<
11488 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11489 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11490>
11491{
11492 #[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"]
11493 fn duplicate(
11494 &mut self,
11495
11496 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
11497
11498 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
11499 ) -> impl ::core::future::Future<Output = ()>;
11500
11501 #[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"]
11502 fn drop(
11503 &mut self,
11504
11505 request: ::fidl_next::Request<capability_store::Drop, ___T>,
11506
11507 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
11508 ) -> impl ::core::future::Future<Output = ()>;
11509
11510 #[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"]
11511 fn export(
11512 &mut self,
11513
11514 request: ::fidl_next::Request<capability_store::Export, ___T>,
11515
11516 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
11517 ) -> impl ::core::future::Future<Output = ()>;
11518
11519 #[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"]
11520 fn import(
11521 &mut self,
11522
11523 request: ::fidl_next::Request<capability_store::Import, ___T>,
11524
11525 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
11526 ) -> impl ::core::future::Future<Output = ()>;
11527
11528 #[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"]
11529 fn connector_create(
11530 &mut self,
11531
11532 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
11533
11534 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
11535 ) -> impl ::core::future::Future<Output = ()>;
11536
11537 #[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"]
11538 fn connector_open(
11539 &mut self,
11540
11541 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
11542
11543 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
11544 ) -> impl ::core::future::Future<Output = ()>;
11545
11546 #[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"]
11547 fn dir_connector_create(
11548 &mut self,
11549
11550 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
11551
11552 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
11553 ) -> impl ::core::future::Future<Output = ()>;
11554
11555 #[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"]
11556 fn dir_connector_open(
11557 &mut self,
11558
11559 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
11560
11561 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
11562 ) -> impl ::core::future::Future<Output = ()>;
11563
11564 #[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"]
11565 fn dictionary_create(
11566 &mut self,
11567
11568 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
11569
11570 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
11571 ) -> impl ::core::future::Future<Output = ()>;
11572
11573 #[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"]
11574 fn dictionary_legacy_import(
11575 &mut self,
11576
11577 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
11578
11579 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
11580 ) -> impl ::core::future::Future<Output = ()>;
11581
11582 #[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"]
11583 fn dictionary_legacy_export(
11584 &mut self,
11585
11586 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
11587
11588 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
11589 ) -> impl ::core::future::Future<Output = ()>;
11590
11591 #[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"]
11592 fn dictionary_insert(
11593 &mut self,
11594
11595 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
11596
11597 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
11598 ) -> impl ::core::future::Future<Output = ()>;
11599
11600 #[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"]
11601 fn dictionary_get(
11602 &mut self,
11603
11604 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
11605
11606 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
11607 ) -> impl ::core::future::Future<Output = ()>;
11608
11609 #[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"]
11610 fn dictionary_remove(
11611 &mut self,
11612
11613 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
11614
11615 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
11616 ) -> impl ::core::future::Future<Output = ()>;
11617
11618 #[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"]
11619 fn dictionary_copy(
11620 &mut self,
11621
11622 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
11623
11624 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
11625 ) -> impl ::core::future::Future<Output = ()>;
11626
11627 #[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"]
11628 fn dictionary_keys(
11629 &mut self,
11630
11631 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
11632
11633 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
11634 ) -> impl ::core::future::Future<Output = ()>;
11635
11636 #[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"]
11637 fn dictionary_enumerate(
11638 &mut self,
11639
11640 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
11641
11642 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
11643 ) -> impl ::core::future::Future<Output = ()>;
11644
11645 #[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"]
11646 fn dictionary_drain(
11647 &mut self,
11648
11649 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
11650
11651 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
11652 ) -> impl ::core::future::Future<Output = ()>;
11653
11654 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
11655 fn create_service_aggregate(
11656 &mut self,
11657
11658 request: ::fidl_next::Request<capability_store::CreateServiceAggregate, ___T>,
11659
11660 responder: ::fidl_next::Responder<capability_store::CreateServiceAggregate, ___T>,
11661 ) -> impl ::core::future::Future<Output = ()>;
11662
11663 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11664 ::core::future::ready(())
11665 }
11666}
11667
11668impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for CapabilityStore
11669where
11670 ___H: CapabilityStoreLocalServerHandler<___T>,
11671 ___T: ::fidl_next::Transport,
11672 for<'de> crate::wire::CapabilityStoreDuplicateRequest: ::fidl_next::Decode<
11673 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11674 Constraint = (),
11675 >,
11676 for<'de> crate::wire::CapabilityStoreDropRequest: ::fidl_next::Decode<
11677 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11678 Constraint = (),
11679 >,
11680 for<'de> crate::wire::CapabilityStoreExportRequest: ::fidl_next::Decode<
11681 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11682 Constraint = (),
11683 >,
11684 for<'de> crate::wire::CapabilityStoreImportRequest<'de>: ::fidl_next::Decode<
11685 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11686 Constraint = (),
11687 >,
11688 for<'de> crate::wire::CapabilityStoreConnectorCreateRequest: ::fidl_next::Decode<
11689 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11690 Constraint = (),
11691 >,
11692 for<'de> crate::wire::CapabilityStoreConnectorOpenRequest: ::fidl_next::Decode<
11693 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11694 Constraint = (),
11695 >,
11696 for<'de> crate::wire::CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Decode<
11697 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11698 Constraint = (),
11699 >,
11700 for<'de> crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>: ::fidl_next::Decode<
11701 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11702 Constraint = (),
11703 >,
11704 for<'de> crate::wire::CapabilityStoreDictionaryCreateRequest: ::fidl_next::Decode<
11705 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11706 Constraint = (),
11707 >,
11708 for<'de> crate::wire::CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Decode<
11709 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11710 Constraint = (),
11711 >,
11712 for<'de> crate::wire::CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Decode<
11713 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11714 Constraint = (),
11715 >,
11716 for<'de> crate::wire::CapabilityStoreDictionaryInsertRequest<'de>: ::fidl_next::Decode<
11717 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11718 Constraint = (),
11719 >,
11720 for<'de> crate::wire::CapabilityStoreDictionaryGetRequest<'de>: ::fidl_next::Decode<
11721 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11722 Constraint = (),
11723 >,
11724 for<'de> crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>: ::fidl_next::Decode<
11725 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11726 Constraint = (),
11727 >,
11728 for<'de> crate::wire::CapabilityStoreDictionaryCopyRequest: ::fidl_next::Decode<
11729 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11730 Constraint = (),
11731 >,
11732 for<'de> crate::wire::CapabilityStoreDictionaryKeysRequest: ::fidl_next::Decode<
11733 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11734 Constraint = (),
11735 >,
11736 for<'de> crate::wire::CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Decode<
11737 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11738 Constraint = (),
11739 >,
11740 for<'de> crate::wire::CapabilityStoreDictionaryDrainRequest: ::fidl_next::Decode<
11741 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11742 Constraint = (),
11743 >,
11744 for<'de> crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>: ::fidl_next::Decode<
11745 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11746 Constraint = (),
11747 >,
11748{
11749 async fn on_one_way(
11750 handler: &mut ___H,
11751 mut message: ::fidl_next::Message<___T>,
11752 ) -> ::core::result::Result<
11753 (),
11754 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11755 > {
11756 match *message.header().ordinal {
11757 ordinal => {
11758 handler.on_unknown_interaction(ordinal).await;
11759 if ::core::matches!(
11760 message.header().flexibility(),
11761 ::fidl_next::protocol::Flexibility::Strict
11762 ) {
11763 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11764 } else {
11765 Ok(())
11766 }
11767 }
11768 }
11769 }
11770
11771 async fn on_two_way(
11772 handler: &mut ___H,
11773 mut message: ::fidl_next::Message<___T>,
11774 responder: ::fidl_next::protocol::Responder<___T>,
11775 ) -> ::core::result::Result<
11776 (),
11777 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11778 > {
11779 match *message.header().ordinal {
11780 6727592627741008260 => {
11781 let responder = ::fidl_next::Responder::from_untyped(responder);
11782
11783 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11784 Ok(decoded) => {
11785 handler
11786 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
11787 .await;
11788 Ok(())
11789 }
11790 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11791 ordinal: 6727592627741008260,
11792 error,
11793 }),
11794 }
11795 }
11796
11797 753328233834620249 => {
11798 let responder = ::fidl_next::Responder::from_untyped(responder);
11799
11800 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11801 Ok(decoded) => {
11802 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
11803 Ok(())
11804 }
11805 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11806 ordinal: 753328233834620249,
11807 error,
11808 }),
11809 }
11810 }
11811
11812 226159162093533951 => {
11813 let responder = ::fidl_next::Responder::from_untyped(responder);
11814
11815 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11816 Ok(decoded) => {
11817 handler
11818 .export(::fidl_next::Request::from_decoded(decoded), responder)
11819 .await;
11820 Ok(())
11821 }
11822 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11823 ordinal: 226159162093533951,
11824 error,
11825 }),
11826 }
11827 }
11828
11829 2276030276116435867 => {
11830 let responder = ::fidl_next::Responder::from_untyped(responder);
11831
11832 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11833 Ok(decoded) => {
11834 handler
11835 .import(::fidl_next::Request::from_decoded(decoded), responder)
11836 .await;
11837 Ok(())
11838 }
11839 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11840 ordinal: 2276030276116435867,
11841 error,
11842 }),
11843 }
11844 }
11845
11846 2979461408102095909 => {
11847 let responder = ::fidl_next::Responder::from_untyped(responder);
11848
11849 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11850 Ok(decoded) => {
11851 handler
11852 .connector_create(
11853 ::fidl_next::Request::from_decoded(decoded),
11854 responder,
11855 )
11856 .await;
11857 Ok(())
11858 }
11859 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11860 ordinal: 2979461408102095909,
11861 error,
11862 }),
11863 }
11864 }
11865
11866 6016362336453278623 => {
11867 let responder = ::fidl_next::Responder::from_untyped(responder);
11868
11869 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11870 Ok(decoded) => {
11871 handler
11872 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
11873 .await;
11874 Ok(())
11875 }
11876 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11877 ordinal: 6016362336453278623,
11878 error,
11879 }),
11880 }
11881 }
11882
11883 1756747594275428795 => {
11884 let responder = ::fidl_next::Responder::from_untyped(responder);
11885
11886 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11887 Ok(decoded) => {
11888 handler
11889 .dir_connector_create(
11890 ::fidl_next::Request::from_decoded(decoded),
11891 responder,
11892 )
11893 .await;
11894 Ok(())
11895 }
11896 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11897 ordinal: 1756747594275428795,
11898 error,
11899 }),
11900 }
11901 }
11902
11903 6219704004220369153 => {
11904 let responder = ::fidl_next::Responder::from_untyped(responder);
11905
11906 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11907 Ok(decoded) => {
11908 handler
11909 .dir_connector_open(
11910 ::fidl_next::Request::from_decoded(decoded),
11911 responder,
11912 )
11913 .await;
11914 Ok(())
11915 }
11916 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11917 ordinal: 6219704004220369153,
11918 error,
11919 }),
11920 }
11921 }
11922
11923 7608770958894948499 => {
11924 let responder = ::fidl_next::Responder::from_untyped(responder);
11925
11926 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11927 Ok(decoded) => {
11928 handler
11929 .dictionary_create(
11930 ::fidl_next::Request::from_decoded(decoded),
11931 responder,
11932 )
11933 .await;
11934 Ok(())
11935 }
11936 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11937 ordinal: 7608770958894948499,
11938 error,
11939 }),
11940 }
11941 }
11942
11943 8285893703432012383 => {
11944 let responder = ::fidl_next::Responder::from_untyped(responder);
11945
11946 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11947 Ok(decoded) => {
11948 handler
11949 .dictionary_legacy_import(
11950 ::fidl_next::Request::from_decoded(decoded),
11951 responder,
11952 )
11953 .await;
11954 Ok(())
11955 }
11956 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11957 ordinal: 8285893703432012383,
11958 error,
11959 }),
11960 }
11961 }
11962
11963 4647175832683306445 => {
11964 let responder = ::fidl_next::Responder::from_untyped(responder);
11965
11966 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11967 Ok(decoded) => {
11968 handler
11969 .dictionary_legacy_export(
11970 ::fidl_next::Request::from_decoded(decoded),
11971 responder,
11972 )
11973 .await;
11974 Ok(())
11975 }
11976 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11977 ordinal: 4647175832683306445,
11978 error,
11979 }),
11980 }
11981 }
11982
11983 8575443262986538023 => {
11984 let responder = ::fidl_next::Responder::from_untyped(responder);
11985
11986 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11987 Ok(decoded) => {
11988 handler
11989 .dictionary_insert(
11990 ::fidl_next::Request::from_decoded(decoded),
11991 responder,
11992 )
11993 .await;
11994 Ok(())
11995 }
11996 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11997 ordinal: 8575443262986538023,
11998 error,
11999 }),
12000 }
12001 }
12002
12003 5592951026866236882 => {
12004 let responder = ::fidl_next::Responder::from_untyped(responder);
12005
12006 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12007 Ok(decoded) => {
12008 handler
12009 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
12010 .await;
12011 Ok(())
12012 }
12013 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12014 ordinal: 5592951026866236882,
12015 error,
12016 }),
12017 }
12018 }
12019
12020 343892214579320051 => {
12021 let responder = ::fidl_next::Responder::from_untyped(responder);
12022
12023 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12024 Ok(decoded) => {
12025 handler
12026 .dictionary_remove(
12027 ::fidl_next::Request::from_decoded(decoded),
12028 responder,
12029 )
12030 .await;
12031 Ok(())
12032 }
12033 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12034 ordinal: 343892214579320051,
12035 error,
12036 }),
12037 }
12038 }
12039
12040 3977783339739362383 => {
12041 let responder = ::fidl_next::Responder::from_untyped(responder);
12042
12043 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12044 Ok(decoded) => {
12045 handler
12046 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
12047 .await;
12048 Ok(())
12049 }
12050 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12051 ordinal: 3977783339739362383,
12052 error,
12053 }),
12054 }
12055 }
12056
12057 597577248872787102 => {
12058 let responder = ::fidl_next::Responder::from_untyped(responder);
12059
12060 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12061 Ok(decoded) => {
12062 handler
12063 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
12064 .await;
12065 Ok(())
12066 }
12067 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12068 ordinal: 597577248872787102,
12069 error,
12070 }),
12071 }
12072 }
12073
12074 964467096271472193 => {
12075 let responder = ::fidl_next::Responder::from_untyped(responder);
12076
12077 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12078 Ok(decoded) => {
12079 handler
12080 .dictionary_enumerate(
12081 ::fidl_next::Request::from_decoded(decoded),
12082 responder,
12083 )
12084 .await;
12085 Ok(())
12086 }
12087 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12088 ordinal: 964467096271472193,
12089 error,
12090 }),
12091 }
12092 }
12093
12094 2928364469569621208 => {
12095 let responder = ::fidl_next::Responder::from_untyped(responder);
12096
12097 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12098 Ok(decoded) => {
12099 handler
12100 .dictionary_drain(
12101 ::fidl_next::Request::from_decoded(decoded),
12102 responder,
12103 )
12104 .await;
12105 Ok(())
12106 }
12107 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12108 ordinal: 2928364469569621208,
12109 error,
12110 }),
12111 }
12112 }
12113
12114 5009147843253209178 => {
12115 let responder = ::fidl_next::Responder::from_untyped(responder);
12116
12117 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12118 Ok(decoded) => {
12119 handler
12120 .create_service_aggregate(
12121 ::fidl_next::Request::from_decoded(decoded),
12122 responder,
12123 )
12124 .await;
12125 Ok(())
12126 }
12127 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12128 ordinal: 5009147843253209178,
12129 error,
12130 }),
12131 }
12132 }
12133
12134 ordinal => {
12135 handler.on_unknown_interaction(ordinal).await;
12136 if ::core::matches!(
12137 message.header().flexibility(),
12138 ::fidl_next::protocol::Flexibility::Strict
12139 ) {
12140 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12141 } else {
12142 responder
12143 .respond_framework_error(
12144 ordinal,
12145 ::fidl_next::FrameworkError::UnknownMethod,
12146 )
12147 .expect("encoding a framework error should never fail")
12148 .await?;
12149 Ok(())
12150 }
12151 }
12152 }
12153 }
12154}
12155
12156pub trait CapabilityStoreClientHandler<
12160 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12161 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12162>
12163{
12164 fn on_unknown_interaction(
12165 &mut self,
12166 ordinal: u64,
12167 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12168 ::core::future::ready(())
12169 }
12170}
12171
12172impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
12173where
12174 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
12175 ___T: ::fidl_next::Transport,
12176{
12177 async fn on_event(
12178 handler: &mut ___H,
12179 mut message: ::fidl_next::Message<___T>,
12180 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12181 match *message.header().ordinal {
12182 ordinal => {
12183 handler.on_unknown_interaction(ordinal).await;
12184 if ::core::matches!(
12185 message.header().flexibility(),
12186 ::fidl_next::protocol::Flexibility::Strict
12187 ) {
12188 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12189 } else {
12190 Ok(())
12191 }
12192 }
12193 }
12194 }
12195}
12196
12197pub trait CapabilityStoreServerHandler<
12201 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12202 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12203>
12204{
12205 #[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"]
12206 fn duplicate(
12207 &mut self,
12208
12209 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
12210
12211 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
12212 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12213
12214 #[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"]
12215 fn drop(
12216 &mut self,
12217
12218 request: ::fidl_next::Request<capability_store::Drop, ___T>,
12219
12220 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
12221 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12222
12223 #[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"]
12224 fn export(
12225 &mut self,
12226
12227 request: ::fidl_next::Request<capability_store::Export, ___T>,
12228
12229 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
12230 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12231
12232 #[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"]
12233 fn import(
12234 &mut self,
12235
12236 request: ::fidl_next::Request<capability_store::Import, ___T>,
12237
12238 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
12239 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12240
12241 #[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"]
12242 fn connector_create(
12243 &mut self,
12244
12245 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
12246
12247 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
12248 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12249
12250 #[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"]
12251 fn connector_open(
12252 &mut self,
12253
12254 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
12255
12256 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
12257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12258
12259 #[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"]
12260 fn dir_connector_create(
12261 &mut self,
12262
12263 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
12264
12265 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
12266 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12267
12268 #[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"]
12269 fn dir_connector_open(
12270 &mut self,
12271
12272 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
12273
12274 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
12275 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12276
12277 #[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"]
12278 fn dictionary_create(
12279 &mut self,
12280
12281 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
12282
12283 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
12284 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12285
12286 #[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"]
12287 fn dictionary_legacy_import(
12288 &mut self,
12289
12290 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
12291
12292 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
12293 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12294
12295 #[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"]
12296 fn dictionary_legacy_export(
12297 &mut self,
12298
12299 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
12300
12301 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
12302 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12303
12304 #[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"]
12305 fn dictionary_insert(
12306 &mut self,
12307
12308 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
12309
12310 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
12311 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12312
12313 #[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"]
12314 fn dictionary_get(
12315 &mut self,
12316
12317 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
12318
12319 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
12320 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12321
12322 #[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"]
12323 fn dictionary_remove(
12324 &mut self,
12325
12326 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
12327
12328 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
12329 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12330
12331 #[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"]
12332 fn dictionary_copy(
12333 &mut self,
12334
12335 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
12336
12337 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
12338 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12339
12340 #[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"]
12341 fn dictionary_keys(
12342 &mut self,
12343
12344 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
12345
12346 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
12347 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12348
12349 #[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"]
12350 fn dictionary_enumerate(
12351 &mut self,
12352
12353 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
12354
12355 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
12356 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12357
12358 #[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"]
12359 fn dictionary_drain(
12360 &mut self,
12361
12362 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
12363
12364 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
12365 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12366
12367 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
12368 fn create_service_aggregate(
12369 &mut self,
12370
12371 request: ::fidl_next::Request<capability_store::CreateServiceAggregate, ___T>,
12372
12373 responder: ::fidl_next::Responder<capability_store::CreateServiceAggregate, ___T>,
12374 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12375
12376 fn on_unknown_interaction(
12377 &mut self,
12378 ordinal: u64,
12379 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12380 ::core::future::ready(())
12381 }
12382}
12383
12384impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
12385where
12386 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
12387 ___T: ::fidl_next::Transport,
12388 for<'de> crate::wire::CapabilityStoreDuplicateRequest: ::fidl_next::Decode<
12389 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12390 Constraint = (),
12391 >,
12392 for<'de> crate::wire::CapabilityStoreDropRequest: ::fidl_next::Decode<
12393 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12394 Constraint = (),
12395 >,
12396 for<'de> crate::wire::CapabilityStoreExportRequest: ::fidl_next::Decode<
12397 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12398 Constraint = (),
12399 >,
12400 for<'de> crate::wire::CapabilityStoreImportRequest<'de>: ::fidl_next::Decode<
12401 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12402 Constraint = (),
12403 >,
12404 for<'de> crate::wire::CapabilityStoreConnectorCreateRequest: ::fidl_next::Decode<
12405 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12406 Constraint = (),
12407 >,
12408 for<'de> crate::wire::CapabilityStoreConnectorOpenRequest: ::fidl_next::Decode<
12409 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12410 Constraint = (),
12411 >,
12412 for<'de> crate::wire::CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Decode<
12413 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12414 Constraint = (),
12415 >,
12416 for<'de> crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>: ::fidl_next::Decode<
12417 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12418 Constraint = (),
12419 >,
12420 for<'de> crate::wire::CapabilityStoreDictionaryCreateRequest: ::fidl_next::Decode<
12421 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12422 Constraint = (),
12423 >,
12424 for<'de> crate::wire::CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Decode<
12425 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12426 Constraint = (),
12427 >,
12428 for<'de> crate::wire::CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Decode<
12429 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12430 Constraint = (),
12431 >,
12432 for<'de> crate::wire::CapabilityStoreDictionaryInsertRequest<'de>: ::fidl_next::Decode<
12433 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12434 Constraint = (),
12435 >,
12436 for<'de> crate::wire::CapabilityStoreDictionaryGetRequest<'de>: ::fidl_next::Decode<
12437 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12438 Constraint = (),
12439 >,
12440 for<'de> crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>: ::fidl_next::Decode<
12441 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12442 Constraint = (),
12443 >,
12444 for<'de> crate::wire::CapabilityStoreDictionaryCopyRequest: ::fidl_next::Decode<
12445 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12446 Constraint = (),
12447 >,
12448 for<'de> crate::wire::CapabilityStoreDictionaryKeysRequest: ::fidl_next::Decode<
12449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12450 Constraint = (),
12451 >,
12452 for<'de> crate::wire::CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Decode<
12453 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12454 Constraint = (),
12455 >,
12456 for<'de> crate::wire::CapabilityStoreDictionaryDrainRequest: ::fidl_next::Decode<
12457 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12458 Constraint = (),
12459 >,
12460 for<'de> crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>: ::fidl_next::Decode<
12461 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12462 Constraint = (),
12463 >,
12464{
12465 async fn on_one_way(
12466 handler: &mut ___H,
12467 mut message: ::fidl_next::Message<___T>,
12468 ) -> ::core::result::Result<
12469 (),
12470 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12471 > {
12472 match *message.header().ordinal {
12473 ordinal => {
12474 handler.on_unknown_interaction(ordinal).await;
12475 if ::core::matches!(
12476 message.header().flexibility(),
12477 ::fidl_next::protocol::Flexibility::Strict
12478 ) {
12479 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12480 } else {
12481 Ok(())
12482 }
12483 }
12484 }
12485 }
12486
12487 async fn on_two_way(
12488 handler: &mut ___H,
12489 mut message: ::fidl_next::Message<___T>,
12490 responder: ::fidl_next::protocol::Responder<___T>,
12491 ) -> ::core::result::Result<
12492 (),
12493 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12494 > {
12495 match *message.header().ordinal {
12496 6727592627741008260 => {
12497 let responder = ::fidl_next::Responder::from_untyped(responder);
12498
12499 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12500 Ok(decoded) => {
12501 handler
12502 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
12503 .await;
12504 Ok(())
12505 }
12506 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12507 ordinal: 6727592627741008260,
12508 error,
12509 }),
12510 }
12511 }
12512
12513 753328233834620249 => {
12514 let responder = ::fidl_next::Responder::from_untyped(responder);
12515
12516 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12517 Ok(decoded) => {
12518 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
12519 Ok(())
12520 }
12521 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12522 ordinal: 753328233834620249,
12523 error,
12524 }),
12525 }
12526 }
12527
12528 226159162093533951 => {
12529 let responder = ::fidl_next::Responder::from_untyped(responder);
12530
12531 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12532 Ok(decoded) => {
12533 handler
12534 .export(::fidl_next::Request::from_decoded(decoded), responder)
12535 .await;
12536 Ok(())
12537 }
12538 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12539 ordinal: 226159162093533951,
12540 error,
12541 }),
12542 }
12543 }
12544
12545 2276030276116435867 => {
12546 let responder = ::fidl_next::Responder::from_untyped(responder);
12547
12548 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12549 Ok(decoded) => {
12550 handler
12551 .import(::fidl_next::Request::from_decoded(decoded), responder)
12552 .await;
12553 Ok(())
12554 }
12555 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12556 ordinal: 2276030276116435867,
12557 error,
12558 }),
12559 }
12560 }
12561
12562 2979461408102095909 => {
12563 let responder = ::fidl_next::Responder::from_untyped(responder);
12564
12565 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12566 Ok(decoded) => {
12567 handler
12568 .connector_create(
12569 ::fidl_next::Request::from_decoded(decoded),
12570 responder,
12571 )
12572 .await;
12573 Ok(())
12574 }
12575 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12576 ordinal: 2979461408102095909,
12577 error,
12578 }),
12579 }
12580 }
12581
12582 6016362336453278623 => {
12583 let responder = ::fidl_next::Responder::from_untyped(responder);
12584
12585 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12586 Ok(decoded) => {
12587 handler
12588 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
12589 .await;
12590 Ok(())
12591 }
12592 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12593 ordinal: 6016362336453278623,
12594 error,
12595 }),
12596 }
12597 }
12598
12599 1756747594275428795 => {
12600 let responder = ::fidl_next::Responder::from_untyped(responder);
12601
12602 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12603 Ok(decoded) => {
12604 handler
12605 .dir_connector_create(
12606 ::fidl_next::Request::from_decoded(decoded),
12607 responder,
12608 )
12609 .await;
12610 Ok(())
12611 }
12612 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12613 ordinal: 1756747594275428795,
12614 error,
12615 }),
12616 }
12617 }
12618
12619 6219704004220369153 => {
12620 let responder = ::fidl_next::Responder::from_untyped(responder);
12621
12622 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12623 Ok(decoded) => {
12624 handler
12625 .dir_connector_open(
12626 ::fidl_next::Request::from_decoded(decoded),
12627 responder,
12628 )
12629 .await;
12630 Ok(())
12631 }
12632 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12633 ordinal: 6219704004220369153,
12634 error,
12635 }),
12636 }
12637 }
12638
12639 7608770958894948499 => {
12640 let responder = ::fidl_next::Responder::from_untyped(responder);
12641
12642 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12643 Ok(decoded) => {
12644 handler
12645 .dictionary_create(
12646 ::fidl_next::Request::from_decoded(decoded),
12647 responder,
12648 )
12649 .await;
12650 Ok(())
12651 }
12652 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12653 ordinal: 7608770958894948499,
12654 error,
12655 }),
12656 }
12657 }
12658
12659 8285893703432012383 => {
12660 let responder = ::fidl_next::Responder::from_untyped(responder);
12661
12662 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12663 Ok(decoded) => {
12664 handler
12665 .dictionary_legacy_import(
12666 ::fidl_next::Request::from_decoded(decoded),
12667 responder,
12668 )
12669 .await;
12670 Ok(())
12671 }
12672 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12673 ordinal: 8285893703432012383,
12674 error,
12675 }),
12676 }
12677 }
12678
12679 4647175832683306445 => {
12680 let responder = ::fidl_next::Responder::from_untyped(responder);
12681
12682 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12683 Ok(decoded) => {
12684 handler
12685 .dictionary_legacy_export(
12686 ::fidl_next::Request::from_decoded(decoded),
12687 responder,
12688 )
12689 .await;
12690 Ok(())
12691 }
12692 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12693 ordinal: 4647175832683306445,
12694 error,
12695 }),
12696 }
12697 }
12698
12699 8575443262986538023 => {
12700 let responder = ::fidl_next::Responder::from_untyped(responder);
12701
12702 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12703 Ok(decoded) => {
12704 handler
12705 .dictionary_insert(
12706 ::fidl_next::Request::from_decoded(decoded),
12707 responder,
12708 )
12709 .await;
12710 Ok(())
12711 }
12712 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12713 ordinal: 8575443262986538023,
12714 error,
12715 }),
12716 }
12717 }
12718
12719 5592951026866236882 => {
12720 let responder = ::fidl_next::Responder::from_untyped(responder);
12721
12722 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12723 Ok(decoded) => {
12724 handler
12725 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
12726 .await;
12727 Ok(())
12728 }
12729 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12730 ordinal: 5592951026866236882,
12731 error,
12732 }),
12733 }
12734 }
12735
12736 343892214579320051 => {
12737 let responder = ::fidl_next::Responder::from_untyped(responder);
12738
12739 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12740 Ok(decoded) => {
12741 handler
12742 .dictionary_remove(
12743 ::fidl_next::Request::from_decoded(decoded),
12744 responder,
12745 )
12746 .await;
12747 Ok(())
12748 }
12749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12750 ordinal: 343892214579320051,
12751 error,
12752 }),
12753 }
12754 }
12755
12756 3977783339739362383 => {
12757 let responder = ::fidl_next::Responder::from_untyped(responder);
12758
12759 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12760 Ok(decoded) => {
12761 handler
12762 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
12763 .await;
12764 Ok(())
12765 }
12766 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12767 ordinal: 3977783339739362383,
12768 error,
12769 }),
12770 }
12771 }
12772
12773 597577248872787102 => {
12774 let responder = ::fidl_next::Responder::from_untyped(responder);
12775
12776 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12777 Ok(decoded) => {
12778 handler
12779 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
12780 .await;
12781 Ok(())
12782 }
12783 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12784 ordinal: 597577248872787102,
12785 error,
12786 }),
12787 }
12788 }
12789
12790 964467096271472193 => {
12791 let responder = ::fidl_next::Responder::from_untyped(responder);
12792
12793 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12794 Ok(decoded) => {
12795 handler
12796 .dictionary_enumerate(
12797 ::fidl_next::Request::from_decoded(decoded),
12798 responder,
12799 )
12800 .await;
12801 Ok(())
12802 }
12803 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12804 ordinal: 964467096271472193,
12805 error,
12806 }),
12807 }
12808 }
12809
12810 2928364469569621208 => {
12811 let responder = ::fidl_next::Responder::from_untyped(responder);
12812
12813 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12814 Ok(decoded) => {
12815 handler
12816 .dictionary_drain(
12817 ::fidl_next::Request::from_decoded(decoded),
12818 responder,
12819 )
12820 .await;
12821 Ok(())
12822 }
12823 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12824 ordinal: 2928364469569621208,
12825 error,
12826 }),
12827 }
12828 }
12829
12830 5009147843253209178 => {
12831 let responder = ::fidl_next::Responder::from_untyped(responder);
12832
12833 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12834 Ok(decoded) => {
12835 handler
12836 .create_service_aggregate(
12837 ::fidl_next::Request::from_decoded(decoded),
12838 responder,
12839 )
12840 .await;
12841 Ok(())
12842 }
12843 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12844 ordinal: 5009147843253209178,
12845 error,
12846 }),
12847 }
12848 }
12849
12850 ordinal => {
12851 handler.on_unknown_interaction(ordinal).await;
12852 if ::core::matches!(
12853 message.header().flexibility(),
12854 ::fidl_next::protocol::Flexibility::Strict
12855 ) {
12856 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12857 } else {
12858 responder
12859 .respond_framework_error(
12860 ordinal,
12861 ::fidl_next::FrameworkError::UnknownMethod,
12862 )
12863 .expect("encoding a framework error should never fail")
12864 .await?;
12865 Ok(())
12866 }
12867 }
12868 }
12869 }
12870}
12871
12872impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
12873where
12874 ___T: ::fidl_next::Transport,
12875{
12876 async fn on_unknown_interaction(&mut self, _: u64) {}
12877}
12878
12879impl<___H, ___T> CapabilityStoreLocalClientHandler<___T> for ::fidl_next::Local<___H>
12880where
12881 ___H: CapabilityStoreClientHandler<___T>,
12882 ___T: ::fidl_next::Transport,
12883{
12884 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12885 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12886 }
12887}
12888
12889impl<___H, ___T> CapabilityStoreLocalServerHandler<___T> for ::fidl_next::Local<___H>
12890where
12891 ___H: CapabilityStoreServerHandler<___T>,
12892 ___T: ::fidl_next::Transport,
12893{
12894 async fn duplicate(
12895 &mut self,
12896
12897 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
12898
12899 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
12900 ) {
12901 ___H::duplicate(&mut self.0, request, responder).await
12902 }
12903
12904 async fn drop(
12905 &mut self,
12906
12907 request: ::fidl_next::Request<capability_store::Drop, ___T>,
12908
12909 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
12910 ) {
12911 ___H::drop(&mut self.0, request, responder).await
12912 }
12913
12914 async fn export(
12915 &mut self,
12916
12917 request: ::fidl_next::Request<capability_store::Export, ___T>,
12918
12919 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
12920 ) {
12921 ___H::export(&mut self.0, request, responder).await
12922 }
12923
12924 async fn import(
12925 &mut self,
12926
12927 request: ::fidl_next::Request<capability_store::Import, ___T>,
12928
12929 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
12930 ) {
12931 ___H::import(&mut self.0, request, responder).await
12932 }
12933
12934 async fn connector_create(
12935 &mut self,
12936
12937 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
12938
12939 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
12940 ) {
12941 ___H::connector_create(&mut self.0, request, responder).await
12942 }
12943
12944 async fn connector_open(
12945 &mut self,
12946
12947 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
12948
12949 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
12950 ) {
12951 ___H::connector_open(&mut self.0, request, responder).await
12952 }
12953
12954 async fn dir_connector_create(
12955 &mut self,
12956
12957 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
12958
12959 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
12960 ) {
12961 ___H::dir_connector_create(&mut self.0, request, responder).await
12962 }
12963
12964 async fn dir_connector_open(
12965 &mut self,
12966
12967 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
12968
12969 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
12970 ) {
12971 ___H::dir_connector_open(&mut self.0, request, responder).await
12972 }
12973
12974 async fn dictionary_create(
12975 &mut self,
12976
12977 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
12978
12979 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
12980 ) {
12981 ___H::dictionary_create(&mut self.0, request, responder).await
12982 }
12983
12984 async fn dictionary_legacy_import(
12985 &mut self,
12986
12987 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
12988
12989 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
12990 ) {
12991 ___H::dictionary_legacy_import(&mut self.0, request, responder).await
12992 }
12993
12994 async fn dictionary_legacy_export(
12995 &mut self,
12996
12997 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
12998
12999 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
13000 ) {
13001 ___H::dictionary_legacy_export(&mut self.0, request, responder).await
13002 }
13003
13004 async fn dictionary_insert(
13005 &mut self,
13006
13007 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
13008
13009 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
13010 ) {
13011 ___H::dictionary_insert(&mut self.0, request, responder).await
13012 }
13013
13014 async fn dictionary_get(
13015 &mut self,
13016
13017 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
13018
13019 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
13020 ) {
13021 ___H::dictionary_get(&mut self.0, request, responder).await
13022 }
13023
13024 async fn dictionary_remove(
13025 &mut self,
13026
13027 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
13028
13029 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
13030 ) {
13031 ___H::dictionary_remove(&mut self.0, request, responder).await
13032 }
13033
13034 async fn dictionary_copy(
13035 &mut self,
13036
13037 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
13038
13039 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
13040 ) {
13041 ___H::dictionary_copy(&mut self.0, request, responder).await
13042 }
13043
13044 async fn dictionary_keys(
13045 &mut self,
13046
13047 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
13048
13049 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
13050 ) {
13051 ___H::dictionary_keys(&mut self.0, request, responder).await
13052 }
13053
13054 async fn dictionary_enumerate(
13055 &mut self,
13056
13057 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
13058
13059 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
13060 ) {
13061 ___H::dictionary_enumerate(&mut self.0, request, responder).await
13062 }
13063
13064 async fn dictionary_drain(
13065 &mut self,
13066
13067 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
13068
13069 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
13070 ) {
13071 ___H::dictionary_drain(&mut self.0, request, responder).await
13072 }
13073
13074 async fn create_service_aggregate(
13075 &mut self,
13076
13077 request: ::fidl_next::Request<capability_store::CreateServiceAggregate, ___T>,
13078
13079 responder: ::fidl_next::Responder<capability_store::CreateServiceAggregate, ___T>,
13080 ) {
13081 ___H::create_service_aggregate(&mut self.0, request, responder).await
13082 }
13083
13084 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13085 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13086 }
13087}
13088
13089#[derive(PartialEq, Debug)]
13091pub struct ConnectorRouter;
13092
13093impl ::fidl_next::Discoverable for ConnectorRouter {
13094 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
13095}
13096
13097#[cfg(target_os = "fuchsia")]
13098impl ::fidl_next::HasTransport for ConnectorRouter {
13099 type Transport = ::fidl_next::fuchsia::zx::Channel;
13100}
13101
13102pub mod connector_router {
13103 pub mod prelude {
13104 pub use crate::{
13105 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterLocalClientHandler,
13106 ConnectorRouterLocalServerHandler, ConnectorRouterServerHandler, connector_router,
13107 };
13108
13109 pub use crate::natural::ConnectorRouterRouteResponse;
13110
13111 pub use crate::natural::RouteRequest;
13112
13113 pub use crate::natural::RouterError;
13114 }
13115
13116 pub struct Route;
13117
13118 impl ::fidl_next::Method for Route {
13119 const ORDINAL: u64 = 8420527046218942310;
13120 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13121 ::fidl_next::protocol::Flexibility::Flexible;
13122
13123 type Protocol = crate::ConnectorRouter;
13124
13125 type Request = crate::wire::RouteRequest<'static>;
13126 }
13127
13128 impl ::fidl_next::TwoWayMethod for Route {
13129 type Response = ::fidl_next::wire::Result<
13130 'static,
13131 crate::wire::ConnectorRouterRouteResponse,
13132 crate::wire::RouterError,
13133 >;
13134 }
13135
13136 impl<___R> ::fidl_next::Respond<___R> for Route {
13137 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13138
13139 fn respond(response: ___R) -> Self::Output {
13140 ::core::result::Result::Ok(response)
13141 }
13142 }
13143
13144 impl<___R> ::fidl_next::RespondErr<___R> for Route {
13145 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13146
13147 fn respond_err(response: ___R) -> Self::Output {
13148 ::core::result::Result::Err(response)
13149 }
13150 }
13151
13152 mod ___detail {
13153 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
13154 where
13155 ___T: ::fidl_next::Transport,
13156 {
13157 type Client = ConnectorRouterClient<___T>;
13158 type Server = ConnectorRouterServer<___T>;
13159 }
13160
13161 #[repr(transparent)]
13163 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
13164 #[allow(dead_code)]
13165 client: ::fidl_next::protocol::Client<___T>,
13166 }
13167
13168 impl<___T> ConnectorRouterClient<___T>
13169 where
13170 ___T: ::fidl_next::Transport,
13171 {
13172 pub fn route_with<___R>(
13173 &self,
13174 request: ___R,
13175 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13176 where
13177 ___R: ::fidl_next::Encode<
13178 crate::wire::RouteRequest<'static>,
13179 <___T as ::fidl_next::Transport>::SendBuffer,
13180 >,
13181 {
13182 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13183 8420527046218942310,
13184 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
13185 request,
13186 ))
13187 }
13188 }
13189
13190 #[repr(transparent)]
13192 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
13193 server: ::fidl_next::protocol::Server<___T>,
13194 }
13195
13196 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
13197 }
13198}
13199
13200#[diagnostic::on_unimplemented(
13201 note = "If {Self} implements the non-local ConnectorRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
13202)]
13203
13204pub trait ConnectorRouterLocalClientHandler<
13208 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13209 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13210>
13211{
13212 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
13213 ::core::future::ready(())
13214 }
13215}
13216
13217impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ConnectorRouter
13218where
13219 ___H: ConnectorRouterLocalClientHandler<___T>,
13220 ___T: ::fidl_next::Transport,
13221{
13222 async fn on_event(
13223 handler: &mut ___H,
13224 mut message: ::fidl_next::Message<___T>,
13225 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13226 match *message.header().ordinal {
13227 ordinal => {
13228 handler.on_unknown_interaction(ordinal).await;
13229 if ::core::matches!(
13230 message.header().flexibility(),
13231 ::fidl_next::protocol::Flexibility::Strict
13232 ) {
13233 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13234 } else {
13235 Ok(())
13236 }
13237 }
13238 }
13239 }
13240}
13241
13242#[diagnostic::on_unimplemented(
13243 note = "If {Self} implements the non-local ConnectorRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
13244)]
13245
13246pub trait ConnectorRouterLocalServerHandler<
13250 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13251 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13252>
13253{
13254 fn route(
13255 &mut self,
13256
13257 request: ::fidl_next::Request<connector_router::Route, ___T>,
13258
13259 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
13260 ) -> impl ::core::future::Future<Output = ()>;
13261
13262 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
13263 ::core::future::ready(())
13264 }
13265}
13266
13267impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ConnectorRouter
13268where
13269 ___H: ConnectorRouterLocalServerHandler<___T>,
13270 ___T: ::fidl_next::Transport,
13271 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13272 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13273 Constraint = (),
13274 >,
13275{
13276 async fn on_one_way(
13277 handler: &mut ___H,
13278 mut message: ::fidl_next::Message<___T>,
13279 ) -> ::core::result::Result<
13280 (),
13281 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13282 > {
13283 match *message.header().ordinal {
13284 ordinal => {
13285 handler.on_unknown_interaction(ordinal).await;
13286 if ::core::matches!(
13287 message.header().flexibility(),
13288 ::fidl_next::protocol::Flexibility::Strict
13289 ) {
13290 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13291 } else {
13292 Ok(())
13293 }
13294 }
13295 }
13296 }
13297
13298 async fn on_two_way(
13299 handler: &mut ___H,
13300 mut message: ::fidl_next::Message<___T>,
13301 responder: ::fidl_next::protocol::Responder<___T>,
13302 ) -> ::core::result::Result<
13303 (),
13304 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13305 > {
13306 match *message.header().ordinal {
13307 8420527046218942310 => {
13308 let responder = ::fidl_next::Responder::from_untyped(responder);
13309
13310 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13311 Ok(decoded) => {
13312 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13313 Ok(())
13314 }
13315 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13316 ordinal: 8420527046218942310,
13317 error,
13318 }),
13319 }
13320 }
13321
13322 ordinal => {
13323 handler.on_unknown_interaction(ordinal).await;
13324 if ::core::matches!(
13325 message.header().flexibility(),
13326 ::fidl_next::protocol::Flexibility::Strict
13327 ) {
13328 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13329 } else {
13330 responder
13331 .respond_framework_error(
13332 ordinal,
13333 ::fidl_next::FrameworkError::UnknownMethod,
13334 )
13335 .expect("encoding a framework error should never fail")
13336 .await?;
13337 Ok(())
13338 }
13339 }
13340 }
13341 }
13342}
13343
13344pub trait ConnectorRouterClientHandler<
13348 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13349 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13350>
13351{
13352 fn on_unknown_interaction(
13353 &mut self,
13354 ordinal: u64,
13355 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13356 ::core::future::ready(())
13357 }
13358}
13359
13360impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
13361where
13362 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
13363 ___T: ::fidl_next::Transport,
13364{
13365 async fn on_event(
13366 handler: &mut ___H,
13367 mut message: ::fidl_next::Message<___T>,
13368 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13369 match *message.header().ordinal {
13370 ordinal => {
13371 handler.on_unknown_interaction(ordinal).await;
13372 if ::core::matches!(
13373 message.header().flexibility(),
13374 ::fidl_next::protocol::Flexibility::Strict
13375 ) {
13376 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13377 } else {
13378 Ok(())
13379 }
13380 }
13381 }
13382 }
13383}
13384
13385pub trait ConnectorRouterServerHandler<
13389 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13390 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13391>
13392{
13393 fn route(
13394 &mut self,
13395
13396 request: ::fidl_next::Request<connector_router::Route, ___T>,
13397
13398 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
13399 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13400
13401 fn on_unknown_interaction(
13402 &mut self,
13403 ordinal: u64,
13404 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13405 ::core::future::ready(())
13406 }
13407}
13408
13409impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
13410where
13411 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
13412 ___T: ::fidl_next::Transport,
13413 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13414 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13415 Constraint = (),
13416 >,
13417{
13418 async fn on_one_way(
13419 handler: &mut ___H,
13420 mut message: ::fidl_next::Message<___T>,
13421 ) -> ::core::result::Result<
13422 (),
13423 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13424 > {
13425 match *message.header().ordinal {
13426 ordinal => {
13427 handler.on_unknown_interaction(ordinal).await;
13428 if ::core::matches!(
13429 message.header().flexibility(),
13430 ::fidl_next::protocol::Flexibility::Strict
13431 ) {
13432 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13433 } else {
13434 Ok(())
13435 }
13436 }
13437 }
13438 }
13439
13440 async fn on_two_way(
13441 handler: &mut ___H,
13442 mut message: ::fidl_next::Message<___T>,
13443 responder: ::fidl_next::protocol::Responder<___T>,
13444 ) -> ::core::result::Result<
13445 (),
13446 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13447 > {
13448 match *message.header().ordinal {
13449 8420527046218942310 => {
13450 let responder = ::fidl_next::Responder::from_untyped(responder);
13451
13452 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13453 Ok(decoded) => {
13454 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13455 Ok(())
13456 }
13457 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13458 ordinal: 8420527046218942310,
13459 error,
13460 }),
13461 }
13462 }
13463
13464 ordinal => {
13465 handler.on_unknown_interaction(ordinal).await;
13466 if ::core::matches!(
13467 message.header().flexibility(),
13468 ::fidl_next::protocol::Flexibility::Strict
13469 ) {
13470 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13471 } else {
13472 responder
13473 .respond_framework_error(
13474 ordinal,
13475 ::fidl_next::FrameworkError::UnknownMethod,
13476 )
13477 .expect("encoding a framework error should never fail")
13478 .await?;
13479 Ok(())
13480 }
13481 }
13482 }
13483 }
13484}
13485
13486impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
13487where
13488 ___T: ::fidl_next::Transport,
13489{
13490 async fn on_unknown_interaction(&mut self, _: u64) {}
13491}
13492
13493impl<___H, ___T> ConnectorRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
13494where
13495 ___H: ConnectorRouterClientHandler<___T>,
13496 ___T: ::fidl_next::Transport,
13497{
13498 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13499 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13500 }
13501}
13502
13503impl<___H, ___T> ConnectorRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
13504where
13505 ___H: ConnectorRouterServerHandler<___T>,
13506 ___T: ::fidl_next::Transport,
13507{
13508 async fn route(
13509 &mut self,
13510
13511 request: ::fidl_next::Request<connector_router::Route, ___T>,
13512
13513 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
13514 ) {
13515 ___H::route(&mut self.0, request, responder).await
13516 }
13517
13518 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13519 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13520 }
13521}
13522
13523#[derive(PartialEq, Debug)]
13525pub struct DataRouter;
13526
13527impl ::fidl_next::Discoverable for DataRouter {
13528 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
13529}
13530
13531#[cfg(target_os = "fuchsia")]
13532impl ::fidl_next::HasTransport for DataRouter {
13533 type Transport = ::fidl_next::fuchsia::zx::Channel;
13534}
13535
13536pub mod data_router {
13537 pub mod prelude {
13538 pub use crate::{
13539 DataRouter, DataRouterClientHandler, DataRouterLocalClientHandler,
13540 DataRouterLocalServerHandler, DataRouterServerHandler, data_router,
13541 };
13542
13543 pub use crate::natural::DataRouterRouteResponse;
13544
13545 pub use crate::natural::RouteRequest;
13546
13547 pub use crate::natural::RouterError;
13548 }
13549
13550 pub struct Route;
13551
13552 impl ::fidl_next::Method for Route {
13553 const ORDINAL: u64 = 3352890635970754564;
13554 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13555 ::fidl_next::protocol::Flexibility::Flexible;
13556
13557 type Protocol = crate::DataRouter;
13558
13559 type Request = crate::wire::RouteRequest<'static>;
13560 }
13561
13562 impl ::fidl_next::TwoWayMethod for Route {
13563 type Response = ::fidl_next::wire::Result<
13564 'static,
13565 crate::wire::DataRouterRouteResponse<'static>,
13566 crate::wire::RouterError,
13567 >;
13568 }
13569
13570 impl<___R> ::fidl_next::Respond<___R> for Route {
13571 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13572
13573 fn respond(response: ___R) -> Self::Output {
13574 ::core::result::Result::Ok(response)
13575 }
13576 }
13577
13578 impl<___R> ::fidl_next::RespondErr<___R> for Route {
13579 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13580
13581 fn respond_err(response: ___R) -> Self::Output {
13582 ::core::result::Result::Err(response)
13583 }
13584 }
13585
13586 mod ___detail {
13587 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
13588 where
13589 ___T: ::fidl_next::Transport,
13590 {
13591 type Client = DataRouterClient<___T>;
13592 type Server = DataRouterServer<___T>;
13593 }
13594
13595 #[repr(transparent)]
13597 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
13598 #[allow(dead_code)]
13599 client: ::fidl_next::protocol::Client<___T>,
13600 }
13601
13602 impl<___T> DataRouterClient<___T>
13603 where
13604 ___T: ::fidl_next::Transport,
13605 {
13606 pub fn route_with<___R>(
13607 &self,
13608 request: ___R,
13609 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13610 where
13611 ___R: ::fidl_next::Encode<
13612 crate::wire::RouteRequest<'static>,
13613 <___T as ::fidl_next::Transport>::SendBuffer,
13614 >,
13615 {
13616 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13617 3352890635970754564,
13618 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
13619 request,
13620 ))
13621 }
13622 }
13623
13624 #[repr(transparent)]
13626 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
13627 server: ::fidl_next::protocol::Server<___T>,
13628 }
13629
13630 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
13631 }
13632}
13633
13634#[diagnostic::on_unimplemented(
13635 note = "If {Self} implements the non-local DataRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
13636)]
13637
13638pub trait DataRouterLocalClientHandler<
13642 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13643 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13644>
13645{
13646 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
13647 ::core::future::ready(())
13648 }
13649}
13650
13651impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DataRouter
13652where
13653 ___H: DataRouterLocalClientHandler<___T>,
13654 ___T: ::fidl_next::Transport,
13655{
13656 async fn on_event(
13657 handler: &mut ___H,
13658 mut message: ::fidl_next::Message<___T>,
13659 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13660 match *message.header().ordinal {
13661 ordinal => {
13662 handler.on_unknown_interaction(ordinal).await;
13663 if ::core::matches!(
13664 message.header().flexibility(),
13665 ::fidl_next::protocol::Flexibility::Strict
13666 ) {
13667 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13668 } else {
13669 Ok(())
13670 }
13671 }
13672 }
13673 }
13674}
13675
13676#[diagnostic::on_unimplemented(
13677 note = "If {Self} implements the non-local DataRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
13678)]
13679
13680pub trait DataRouterLocalServerHandler<
13684 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13685 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13686>
13687{
13688 fn route(
13689 &mut self,
13690
13691 request: ::fidl_next::Request<data_router::Route, ___T>,
13692
13693 responder: ::fidl_next::Responder<data_router::Route, ___T>,
13694 ) -> impl ::core::future::Future<Output = ()>;
13695
13696 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
13697 ::core::future::ready(())
13698 }
13699}
13700
13701impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DataRouter
13702where
13703 ___H: DataRouterLocalServerHandler<___T>,
13704 ___T: ::fidl_next::Transport,
13705 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13706 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13707 Constraint = (),
13708 >,
13709{
13710 async fn on_one_way(
13711 handler: &mut ___H,
13712 mut message: ::fidl_next::Message<___T>,
13713 ) -> ::core::result::Result<
13714 (),
13715 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13716 > {
13717 match *message.header().ordinal {
13718 ordinal => {
13719 handler.on_unknown_interaction(ordinal).await;
13720 if ::core::matches!(
13721 message.header().flexibility(),
13722 ::fidl_next::protocol::Flexibility::Strict
13723 ) {
13724 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13725 } else {
13726 Ok(())
13727 }
13728 }
13729 }
13730 }
13731
13732 async fn on_two_way(
13733 handler: &mut ___H,
13734 mut message: ::fidl_next::Message<___T>,
13735 responder: ::fidl_next::protocol::Responder<___T>,
13736 ) -> ::core::result::Result<
13737 (),
13738 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13739 > {
13740 match *message.header().ordinal {
13741 3352890635970754564 => {
13742 let responder = ::fidl_next::Responder::from_untyped(responder);
13743
13744 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13745 Ok(decoded) => {
13746 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13747 Ok(())
13748 }
13749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13750 ordinal: 3352890635970754564,
13751 error,
13752 }),
13753 }
13754 }
13755
13756 ordinal => {
13757 handler.on_unknown_interaction(ordinal).await;
13758 if ::core::matches!(
13759 message.header().flexibility(),
13760 ::fidl_next::protocol::Flexibility::Strict
13761 ) {
13762 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13763 } else {
13764 responder
13765 .respond_framework_error(
13766 ordinal,
13767 ::fidl_next::FrameworkError::UnknownMethod,
13768 )
13769 .expect("encoding a framework error should never fail")
13770 .await?;
13771 Ok(())
13772 }
13773 }
13774 }
13775 }
13776}
13777
13778pub trait DataRouterClientHandler<
13782 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13783 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13784>
13785{
13786 fn on_unknown_interaction(
13787 &mut self,
13788 ordinal: u64,
13789 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13790 ::core::future::ready(())
13791 }
13792}
13793
13794impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
13795where
13796 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
13797 ___T: ::fidl_next::Transport,
13798{
13799 async fn on_event(
13800 handler: &mut ___H,
13801 mut message: ::fidl_next::Message<___T>,
13802 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13803 match *message.header().ordinal {
13804 ordinal => {
13805 handler.on_unknown_interaction(ordinal).await;
13806 if ::core::matches!(
13807 message.header().flexibility(),
13808 ::fidl_next::protocol::Flexibility::Strict
13809 ) {
13810 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13811 } else {
13812 Ok(())
13813 }
13814 }
13815 }
13816 }
13817}
13818
13819pub trait DataRouterServerHandler<
13823 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13824 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13825>
13826{
13827 fn route(
13828 &mut self,
13829
13830 request: ::fidl_next::Request<data_router::Route, ___T>,
13831
13832 responder: ::fidl_next::Responder<data_router::Route, ___T>,
13833 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13834
13835 fn on_unknown_interaction(
13836 &mut self,
13837 ordinal: u64,
13838 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13839 ::core::future::ready(())
13840 }
13841}
13842
13843impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
13844where
13845 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
13846 ___T: ::fidl_next::Transport,
13847 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13848 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13849 Constraint = (),
13850 >,
13851{
13852 async fn on_one_way(
13853 handler: &mut ___H,
13854 mut message: ::fidl_next::Message<___T>,
13855 ) -> ::core::result::Result<
13856 (),
13857 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13858 > {
13859 match *message.header().ordinal {
13860 ordinal => {
13861 handler.on_unknown_interaction(ordinal).await;
13862 if ::core::matches!(
13863 message.header().flexibility(),
13864 ::fidl_next::protocol::Flexibility::Strict
13865 ) {
13866 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13867 } else {
13868 Ok(())
13869 }
13870 }
13871 }
13872 }
13873
13874 async fn on_two_way(
13875 handler: &mut ___H,
13876 mut message: ::fidl_next::Message<___T>,
13877 responder: ::fidl_next::protocol::Responder<___T>,
13878 ) -> ::core::result::Result<
13879 (),
13880 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13881 > {
13882 match *message.header().ordinal {
13883 3352890635970754564 => {
13884 let responder = ::fidl_next::Responder::from_untyped(responder);
13885
13886 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13887 Ok(decoded) => {
13888 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13889 Ok(())
13890 }
13891 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13892 ordinal: 3352890635970754564,
13893 error,
13894 }),
13895 }
13896 }
13897
13898 ordinal => {
13899 handler.on_unknown_interaction(ordinal).await;
13900 if ::core::matches!(
13901 message.header().flexibility(),
13902 ::fidl_next::protocol::Flexibility::Strict
13903 ) {
13904 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13905 } else {
13906 responder
13907 .respond_framework_error(
13908 ordinal,
13909 ::fidl_next::FrameworkError::UnknownMethod,
13910 )
13911 .expect("encoding a framework error should never fail")
13912 .await?;
13913 Ok(())
13914 }
13915 }
13916 }
13917 }
13918}
13919
13920impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
13921where
13922 ___T: ::fidl_next::Transport,
13923{
13924 async fn on_unknown_interaction(&mut self, _: u64) {}
13925}
13926
13927impl<___H, ___T> DataRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
13928where
13929 ___H: DataRouterClientHandler<___T>,
13930 ___T: ::fidl_next::Transport,
13931{
13932 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13933 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13934 }
13935}
13936
13937impl<___H, ___T> DataRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
13938where
13939 ___H: DataRouterServerHandler<___T>,
13940 ___T: ::fidl_next::Transport,
13941{
13942 async fn route(
13943 &mut self,
13944
13945 request: ::fidl_next::Request<data_router::Route, ___T>,
13946
13947 responder: ::fidl_next::Responder<data_router::Route, ___T>,
13948 ) {
13949 ___H::route(&mut self.0, request, responder).await
13950 }
13951
13952 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13953 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13954 }
13955}
13956
13957#[derive(PartialEq, Debug)]
13959pub struct DictionaryDrainIterator;
13960
13961#[cfg(target_os = "fuchsia")]
13962impl ::fidl_next::HasTransport for DictionaryDrainIterator {
13963 type Transport = ::fidl_next::fuchsia::zx::Channel;
13964}
13965
13966pub mod dictionary_drain_iterator {
13967 pub mod prelude {
13968 pub use crate::{
13969 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
13970 DictionaryDrainIteratorLocalClientHandler, DictionaryDrainIteratorLocalServerHandler,
13971 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
13972 };
13973
13974 pub use crate::natural::CapabilityStoreError;
13975
13976 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
13977
13978 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
13979 }
13980
13981 pub struct GetNext;
13982
13983 impl ::fidl_next::Method for GetNext {
13984 const ORDINAL: u64 = 5728722530628427873;
13985 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13986 ::fidl_next::protocol::Flexibility::Flexible;
13987
13988 type Protocol = crate::DictionaryDrainIterator;
13989
13990 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
13991 }
13992
13993 impl ::fidl_next::TwoWayMethod for GetNext {
13994 type Response = ::fidl_next::wire::Result<
13995 'static,
13996 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
13997 crate::wire::CapabilityStoreError,
13998 >;
13999 }
14000
14001 impl<___R> ::fidl_next::Respond<___R> for GetNext {
14002 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14003
14004 fn respond(response: ___R) -> Self::Output {
14005 ::core::result::Result::Ok(response)
14006 }
14007 }
14008
14009 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
14010 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14011
14012 fn respond_err(response: ___R) -> Self::Output {
14013 ::core::result::Result::Err(response)
14014 }
14015 }
14016
14017 mod ___detail {
14018 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
14019 where
14020 ___T: ::fidl_next::Transport,
14021 {
14022 type Client = DictionaryDrainIteratorClient<___T>;
14023 type Server = DictionaryDrainIteratorServer<___T>;
14024 }
14025
14026 #[repr(transparent)]
14028 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
14029 #[allow(dead_code)]
14030 client: ::fidl_next::protocol::Client<___T>,
14031 }
14032
14033 impl<___T> DictionaryDrainIteratorClient<___T>
14034 where
14035 ___T: ::fidl_next::Transport,
14036 {
14037 #[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"]
14038 pub fn get_next(
14039 &self,
14040
14041 start_id: impl ::fidl_next::Encode<
14042 ::fidl_next::wire::Uint64,
14043 <___T as ::fidl_next::Transport>::SendBuffer,
14044 >,
14045
14046 limit: impl ::fidl_next::Encode<
14047 ::fidl_next::wire::Uint32,
14048 <___T as ::fidl_next::Transport>::SendBuffer,
14049 >,
14050 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
14051 where
14052 <___T as ::fidl_next::Transport>::SendBuffer:
14053 ::fidl_next::encoder::InternalHandleEncoder,
14054 {
14055 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
14056 start_id,
14057
14058 limit,
14059 })
14060 }
14061
14062 #[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"]
14063 pub fn get_next_with<___R>(
14064 &self,
14065 request: ___R,
14066 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
14067 where
14068 ___R: ::fidl_next::Encode<
14069 crate::wire::DictionaryDrainIteratorGetNextRequest,
14070 <___T as ::fidl_next::Transport>::SendBuffer,
14071 >,
14072 {
14073 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14074 5728722530628427873,
14075 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
14076 request,
14077 ))
14078 }
14079 }
14080
14081 #[repr(transparent)]
14083 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
14084 server: ::fidl_next::protocol::Server<___T>,
14085 }
14086
14087 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
14088 }
14089}
14090
14091#[diagnostic::on_unimplemented(
14092 note = "If {Self} implements the non-local DictionaryDrainIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
14093)]
14094
14095pub trait DictionaryDrainIteratorLocalClientHandler<
14099 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14100 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14101>
14102{
14103 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
14104 ::core::future::ready(())
14105 }
14106}
14107
14108impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DictionaryDrainIterator
14109where
14110 ___H: DictionaryDrainIteratorLocalClientHandler<___T>,
14111 ___T: ::fidl_next::Transport,
14112{
14113 async fn on_event(
14114 handler: &mut ___H,
14115 mut message: ::fidl_next::Message<___T>,
14116 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14117 match *message.header().ordinal {
14118 ordinal => {
14119 handler.on_unknown_interaction(ordinal).await;
14120 if ::core::matches!(
14121 message.header().flexibility(),
14122 ::fidl_next::protocol::Flexibility::Strict
14123 ) {
14124 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14125 } else {
14126 Ok(())
14127 }
14128 }
14129 }
14130 }
14131}
14132
14133#[diagnostic::on_unimplemented(
14134 note = "If {Self} implements the non-local DictionaryDrainIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
14135)]
14136
14137pub trait DictionaryDrainIteratorLocalServerHandler<
14141 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14142 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14143>
14144{
14145 #[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"]
14146 fn get_next(
14147 &mut self,
14148
14149 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
14150
14151 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
14152 ) -> impl ::core::future::Future<Output = ()>;
14153
14154 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
14155 ::core::future::ready(())
14156 }
14157}
14158
14159impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DictionaryDrainIterator
14160where
14161 ___H: DictionaryDrainIteratorLocalServerHandler<___T>,
14162 ___T: ::fidl_next::Transport,
14163 for<'de> crate::wire::DictionaryDrainIteratorGetNextRequest: ::fidl_next::Decode<
14164 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
14165 Constraint = (),
14166 >,
14167{
14168 async fn on_one_way(
14169 handler: &mut ___H,
14170 mut message: ::fidl_next::Message<___T>,
14171 ) -> ::core::result::Result<
14172 (),
14173 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14174 > {
14175 match *message.header().ordinal {
14176 ordinal => {
14177 handler.on_unknown_interaction(ordinal).await;
14178 if ::core::matches!(
14179 message.header().flexibility(),
14180 ::fidl_next::protocol::Flexibility::Strict
14181 ) {
14182 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14183 } else {
14184 Ok(())
14185 }
14186 }
14187 }
14188 }
14189
14190 async fn on_two_way(
14191 handler: &mut ___H,
14192 mut message: ::fidl_next::Message<___T>,
14193 responder: ::fidl_next::protocol::Responder<___T>,
14194 ) -> ::core::result::Result<
14195 (),
14196 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14197 > {
14198 match *message.header().ordinal {
14199 5728722530628427873 => {
14200 let responder = ::fidl_next::Responder::from_untyped(responder);
14201
14202 match ::fidl_next::AsDecoderExt::into_decoded(message) {
14203 Ok(decoded) => {
14204 handler
14205 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
14206 .await;
14207 Ok(())
14208 }
14209 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14210 ordinal: 5728722530628427873,
14211 error,
14212 }),
14213 }
14214 }
14215
14216 ordinal => {
14217 handler.on_unknown_interaction(ordinal).await;
14218 if ::core::matches!(
14219 message.header().flexibility(),
14220 ::fidl_next::protocol::Flexibility::Strict
14221 ) {
14222 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14223 } else {
14224 responder
14225 .respond_framework_error(
14226 ordinal,
14227 ::fidl_next::FrameworkError::UnknownMethod,
14228 )
14229 .expect("encoding a framework error should never fail")
14230 .await?;
14231 Ok(())
14232 }
14233 }
14234 }
14235 }
14236}
14237
14238pub trait DictionaryDrainIteratorClientHandler<
14242 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14243 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14244>
14245{
14246 fn on_unknown_interaction(
14247 &mut self,
14248 ordinal: u64,
14249 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14250 ::core::future::ready(())
14251 }
14252}
14253
14254impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
14255where
14256 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
14257 ___T: ::fidl_next::Transport,
14258{
14259 async fn on_event(
14260 handler: &mut ___H,
14261 mut message: ::fidl_next::Message<___T>,
14262 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14263 match *message.header().ordinal {
14264 ordinal => {
14265 handler.on_unknown_interaction(ordinal).await;
14266 if ::core::matches!(
14267 message.header().flexibility(),
14268 ::fidl_next::protocol::Flexibility::Strict
14269 ) {
14270 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14271 } else {
14272 Ok(())
14273 }
14274 }
14275 }
14276 }
14277}
14278
14279pub trait DictionaryDrainIteratorServerHandler<
14283 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14284 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14285>
14286{
14287 #[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"]
14288 fn get_next(
14289 &mut self,
14290
14291 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
14292
14293 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
14294 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14295
14296 fn on_unknown_interaction(
14297 &mut self,
14298 ordinal: u64,
14299 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14300 ::core::future::ready(())
14301 }
14302}
14303
14304impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
14305where
14306 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
14307 ___T: ::fidl_next::Transport,
14308 for<'de> crate::wire::DictionaryDrainIteratorGetNextRequest: ::fidl_next::Decode<
14309 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
14310 Constraint = (),
14311 >,
14312{
14313 async fn on_one_way(
14314 handler: &mut ___H,
14315 mut message: ::fidl_next::Message<___T>,
14316 ) -> ::core::result::Result<
14317 (),
14318 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14319 > {
14320 match *message.header().ordinal {
14321 ordinal => {
14322 handler.on_unknown_interaction(ordinal).await;
14323 if ::core::matches!(
14324 message.header().flexibility(),
14325 ::fidl_next::protocol::Flexibility::Strict
14326 ) {
14327 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14328 } else {
14329 Ok(())
14330 }
14331 }
14332 }
14333 }
14334
14335 async fn on_two_way(
14336 handler: &mut ___H,
14337 mut message: ::fidl_next::Message<___T>,
14338 responder: ::fidl_next::protocol::Responder<___T>,
14339 ) -> ::core::result::Result<
14340 (),
14341 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14342 > {
14343 match *message.header().ordinal {
14344 5728722530628427873 => {
14345 let responder = ::fidl_next::Responder::from_untyped(responder);
14346
14347 match ::fidl_next::AsDecoderExt::into_decoded(message) {
14348 Ok(decoded) => {
14349 handler
14350 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
14351 .await;
14352 Ok(())
14353 }
14354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14355 ordinal: 5728722530628427873,
14356 error,
14357 }),
14358 }
14359 }
14360
14361 ordinal => {
14362 handler.on_unknown_interaction(ordinal).await;
14363 if ::core::matches!(
14364 message.header().flexibility(),
14365 ::fidl_next::protocol::Flexibility::Strict
14366 ) {
14367 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14368 } else {
14369 responder
14370 .respond_framework_error(
14371 ordinal,
14372 ::fidl_next::FrameworkError::UnknownMethod,
14373 )
14374 .expect("encoding a framework error should never fail")
14375 .await?;
14376 Ok(())
14377 }
14378 }
14379 }
14380 }
14381}
14382
14383impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
14384where
14385 ___T: ::fidl_next::Transport,
14386{
14387 async fn on_unknown_interaction(&mut self, _: u64) {}
14388}
14389
14390impl<___H, ___T> DictionaryDrainIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
14391where
14392 ___H: DictionaryDrainIteratorClientHandler<___T>,
14393 ___T: ::fidl_next::Transport,
14394{
14395 async fn on_unknown_interaction(&mut self, ordinal: u64) {
14396 ___H::on_unknown_interaction(&mut self.0, ordinal).await
14397 }
14398}
14399
14400impl<___H, ___T> DictionaryDrainIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
14401where
14402 ___H: DictionaryDrainIteratorServerHandler<___T>,
14403 ___T: ::fidl_next::Transport,
14404{
14405 async fn get_next(
14406 &mut self,
14407
14408 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
14409
14410 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
14411 ) {
14412 ___H::get_next(&mut self.0, request, responder).await
14413 }
14414
14415 async fn on_unknown_interaction(&mut self, ordinal: u64) {
14416 ___H::on_unknown_interaction(&mut self.0, ordinal).await
14417 }
14418}
14419
14420#[derive(PartialEq, Debug)]
14422pub struct DictionaryEnumerateIterator;
14423
14424#[cfg(target_os = "fuchsia")]
14425impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
14426 type Transport = ::fidl_next::fuchsia::zx::Channel;
14427}
14428
14429pub mod dictionary_enumerate_iterator {
14430 pub mod prelude {
14431 pub use crate::{
14432 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
14433 DictionaryEnumerateIteratorLocalClientHandler,
14434 DictionaryEnumerateIteratorLocalServerHandler,
14435 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
14436 };
14437
14438 pub use crate::natural::CapabilityStoreError;
14439
14440 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
14441
14442 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
14443 }
14444
14445 pub struct GetNext;
14446
14447 impl ::fidl_next::Method for GetNext {
14448 const ORDINAL: u64 = 1511164556663256527;
14449 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14450 ::fidl_next::protocol::Flexibility::Flexible;
14451
14452 type Protocol = crate::DictionaryEnumerateIterator;
14453
14454 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
14455 }
14456
14457 impl ::fidl_next::TwoWayMethod for GetNext {
14458 type Response = ::fidl_next::wire::Result<
14459 'static,
14460 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
14461 crate::wire::CapabilityStoreError,
14462 >;
14463 }
14464
14465 impl<___R> ::fidl_next::Respond<___R> for GetNext {
14466 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14467
14468 fn respond(response: ___R) -> Self::Output {
14469 ::core::result::Result::Ok(response)
14470 }
14471 }
14472
14473 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
14474 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14475
14476 fn respond_err(response: ___R) -> Self::Output {
14477 ::core::result::Result::Err(response)
14478 }
14479 }
14480
14481 mod ___detail {
14482 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
14483 where
14484 ___T: ::fidl_next::Transport,
14485 {
14486 type Client = DictionaryEnumerateIteratorClient<___T>;
14487 type Server = DictionaryEnumerateIteratorServer<___T>;
14488 }
14489
14490 #[repr(transparent)]
14492 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
14493 #[allow(dead_code)]
14494 client: ::fidl_next::protocol::Client<___T>,
14495 }
14496
14497 impl<___T> DictionaryEnumerateIteratorClient<___T>
14498 where
14499 ___T: ::fidl_next::Transport,
14500 {
14501 #[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"]
14502 pub fn get_next(
14503 &self,
14504
14505 start_id: impl ::fidl_next::Encode<
14506 ::fidl_next::wire::Uint64,
14507 <___T as ::fidl_next::Transport>::SendBuffer,
14508 >,
14509
14510 limit: impl ::fidl_next::Encode<
14511 ::fidl_next::wire::Uint32,
14512 <___T as ::fidl_next::Transport>::SendBuffer,
14513 >,
14514 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
14515 where
14516 <___T as ::fidl_next::Transport>::SendBuffer:
14517 ::fidl_next::encoder::InternalHandleEncoder,
14518 {
14519 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
14520 start_id,
14521
14522 limit,
14523 })
14524 }
14525
14526 #[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"]
14527 pub fn get_next_with<___R>(
14528 &self,
14529 request: ___R,
14530 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
14531 where
14532 ___R: ::fidl_next::Encode<
14533 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
14534 <___T as ::fidl_next::Transport>::SendBuffer,
14535 >,
14536 {
14537 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14538 1511164556663256527,
14539 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
14540 request,
14541 ))
14542 }
14543 }
14544
14545 #[repr(transparent)]
14547 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
14548 server: ::fidl_next::protocol::Server<___T>,
14549 }
14550
14551 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
14552 }
14553}
14554
14555#[diagnostic::on_unimplemented(
14556 note = "If {Self} implements the non-local DictionaryEnumerateIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
14557)]
14558
14559pub trait DictionaryEnumerateIteratorLocalClientHandler<
14563 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14564 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14565>
14566{
14567 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
14568 ::core::future::ready(())
14569 }
14570}
14571
14572impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DictionaryEnumerateIterator
14573where
14574 ___H: DictionaryEnumerateIteratorLocalClientHandler<___T>,
14575 ___T: ::fidl_next::Transport,
14576{
14577 async fn on_event(
14578 handler: &mut ___H,
14579 mut message: ::fidl_next::Message<___T>,
14580 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14581 match *message.header().ordinal {
14582 ordinal => {
14583 handler.on_unknown_interaction(ordinal).await;
14584 if ::core::matches!(
14585 message.header().flexibility(),
14586 ::fidl_next::protocol::Flexibility::Strict
14587 ) {
14588 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14589 } else {
14590 Ok(())
14591 }
14592 }
14593 }
14594 }
14595}
14596
14597#[diagnostic::on_unimplemented(
14598 note = "If {Self} implements the non-local DictionaryEnumerateIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
14599)]
14600
14601pub trait DictionaryEnumerateIteratorLocalServerHandler<
14605 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14606 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14607>
14608{
14609 #[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"]
14610 fn get_next(
14611 &mut self,
14612
14613 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
14614
14615 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
14616 ) -> impl ::core::future::Future<Output = ()>;
14617
14618 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
14619 ::core::future::ready(())
14620 }
14621}
14622
14623impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DictionaryEnumerateIterator
14624where
14625 ___H: DictionaryEnumerateIteratorLocalServerHandler<___T>,
14626 ___T: ::fidl_next::Transport,
14627 for<'de> crate::wire::DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Decode<
14628 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
14629 Constraint = (),
14630 >,
14631{
14632 async fn on_one_way(
14633 handler: &mut ___H,
14634 mut message: ::fidl_next::Message<___T>,
14635 ) -> ::core::result::Result<
14636 (),
14637 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14638 > {
14639 match *message.header().ordinal {
14640 ordinal => {
14641 handler.on_unknown_interaction(ordinal).await;
14642 if ::core::matches!(
14643 message.header().flexibility(),
14644 ::fidl_next::protocol::Flexibility::Strict
14645 ) {
14646 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14647 } else {
14648 Ok(())
14649 }
14650 }
14651 }
14652 }
14653
14654 async fn on_two_way(
14655 handler: &mut ___H,
14656 mut message: ::fidl_next::Message<___T>,
14657 responder: ::fidl_next::protocol::Responder<___T>,
14658 ) -> ::core::result::Result<
14659 (),
14660 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14661 > {
14662 match *message.header().ordinal {
14663 1511164556663256527 => {
14664 let responder = ::fidl_next::Responder::from_untyped(responder);
14665
14666 match ::fidl_next::AsDecoderExt::into_decoded(message) {
14667 Ok(decoded) => {
14668 handler
14669 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
14670 .await;
14671 Ok(())
14672 }
14673 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14674 ordinal: 1511164556663256527,
14675 error,
14676 }),
14677 }
14678 }
14679
14680 ordinal => {
14681 handler.on_unknown_interaction(ordinal).await;
14682 if ::core::matches!(
14683 message.header().flexibility(),
14684 ::fidl_next::protocol::Flexibility::Strict
14685 ) {
14686 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14687 } else {
14688 responder
14689 .respond_framework_error(
14690 ordinal,
14691 ::fidl_next::FrameworkError::UnknownMethod,
14692 )
14693 .expect("encoding a framework error should never fail")
14694 .await?;
14695 Ok(())
14696 }
14697 }
14698 }
14699 }
14700}
14701
14702pub trait DictionaryEnumerateIteratorClientHandler<
14706 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14707 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14708>
14709{
14710 fn on_unknown_interaction(
14711 &mut self,
14712 ordinal: u64,
14713 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14714 ::core::future::ready(())
14715 }
14716}
14717
14718impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
14719where
14720 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
14721 ___T: ::fidl_next::Transport,
14722{
14723 async fn on_event(
14724 handler: &mut ___H,
14725 mut message: ::fidl_next::Message<___T>,
14726 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14727 match *message.header().ordinal {
14728 ordinal => {
14729 handler.on_unknown_interaction(ordinal).await;
14730 if ::core::matches!(
14731 message.header().flexibility(),
14732 ::fidl_next::protocol::Flexibility::Strict
14733 ) {
14734 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14735 } else {
14736 Ok(())
14737 }
14738 }
14739 }
14740 }
14741}
14742
14743pub trait DictionaryEnumerateIteratorServerHandler<
14747 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14748 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14749>
14750{
14751 #[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"]
14752 fn get_next(
14753 &mut self,
14754
14755 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
14756
14757 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
14758 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14759
14760 fn on_unknown_interaction(
14761 &mut self,
14762 ordinal: u64,
14763 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
14764 ::core::future::ready(())
14765 }
14766}
14767
14768impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
14769where
14770 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
14771 ___T: ::fidl_next::Transport,
14772 for<'de> crate::wire::DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Decode<
14773 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
14774 Constraint = (),
14775 >,
14776{
14777 async fn on_one_way(
14778 handler: &mut ___H,
14779 mut message: ::fidl_next::Message<___T>,
14780 ) -> ::core::result::Result<
14781 (),
14782 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14783 > {
14784 match *message.header().ordinal {
14785 ordinal => {
14786 handler.on_unknown_interaction(ordinal).await;
14787 if ::core::matches!(
14788 message.header().flexibility(),
14789 ::fidl_next::protocol::Flexibility::Strict
14790 ) {
14791 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14792 } else {
14793 Ok(())
14794 }
14795 }
14796 }
14797 }
14798
14799 async fn on_two_way(
14800 handler: &mut ___H,
14801 mut message: ::fidl_next::Message<___T>,
14802 responder: ::fidl_next::protocol::Responder<___T>,
14803 ) -> ::core::result::Result<
14804 (),
14805 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14806 > {
14807 match *message.header().ordinal {
14808 1511164556663256527 => {
14809 let responder = ::fidl_next::Responder::from_untyped(responder);
14810
14811 match ::fidl_next::AsDecoderExt::into_decoded(message) {
14812 Ok(decoded) => {
14813 handler
14814 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
14815 .await;
14816 Ok(())
14817 }
14818 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14819 ordinal: 1511164556663256527,
14820 error,
14821 }),
14822 }
14823 }
14824
14825 ordinal => {
14826 handler.on_unknown_interaction(ordinal).await;
14827 if ::core::matches!(
14828 message.header().flexibility(),
14829 ::fidl_next::protocol::Flexibility::Strict
14830 ) {
14831 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
14832 } else {
14833 responder
14834 .respond_framework_error(
14835 ordinal,
14836 ::fidl_next::FrameworkError::UnknownMethod,
14837 )
14838 .expect("encoding a framework error should never fail")
14839 .await?;
14840 Ok(())
14841 }
14842 }
14843 }
14844 }
14845}
14846
14847impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
14848where
14849 ___T: ::fidl_next::Transport,
14850{
14851 async fn on_unknown_interaction(&mut self, _: u64) {}
14852}
14853
14854impl<___H, ___T> DictionaryEnumerateIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
14855where
14856 ___H: DictionaryEnumerateIteratorClientHandler<___T>,
14857 ___T: ::fidl_next::Transport,
14858{
14859 async fn on_unknown_interaction(&mut self, ordinal: u64) {
14860 ___H::on_unknown_interaction(&mut self.0, ordinal).await
14861 }
14862}
14863
14864impl<___H, ___T> DictionaryEnumerateIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
14865where
14866 ___H: DictionaryEnumerateIteratorServerHandler<___T>,
14867 ___T: ::fidl_next::Transport,
14868{
14869 async fn get_next(
14870 &mut self,
14871
14872 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
14873
14874 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
14875 ) {
14876 ___H::get_next(&mut self.0, request, responder).await
14877 }
14878
14879 async fn on_unknown_interaction(&mut self, ordinal: u64) {
14880 ___H::on_unknown_interaction(&mut self.0, ordinal).await
14881 }
14882}
14883
14884#[derive(PartialEq, Debug)]
14886pub struct DictionaryKeysIterator;
14887
14888#[cfg(target_os = "fuchsia")]
14889impl ::fidl_next::HasTransport for DictionaryKeysIterator {
14890 type Transport = ::fidl_next::fuchsia::zx::Channel;
14891}
14892
14893pub mod dictionary_keys_iterator {
14894 pub mod prelude {
14895 pub use crate::{
14896 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
14897 DictionaryKeysIteratorLocalClientHandler, DictionaryKeysIteratorLocalServerHandler,
14898 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
14899 };
14900
14901 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
14902 }
14903
14904 pub struct GetNext;
14905
14906 impl ::fidl_next::Method for GetNext {
14907 const ORDINAL: u64 = 4987781442555247955;
14908 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14909 ::fidl_next::protocol::Flexibility::Flexible;
14910
14911 type Protocol = crate::DictionaryKeysIterator;
14912
14913 type Request = ::fidl_next::wire::EmptyMessageBody;
14914 }
14915
14916 impl ::fidl_next::TwoWayMethod for GetNext {
14917 type Response = ::fidl_next::wire::Flexible<
14918 'static,
14919 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
14920 >;
14921 }
14922
14923 impl<___R> ::fidl_next::Respond<___R> for GetNext {
14924 type Output =
14925 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
14926
14927 fn respond(response: ___R) -> Self::Output {
14928 ::fidl_next::Flexible(crate::generic::DictionaryKeysIteratorGetNextResponse {
14929 keys: response,
14930 })
14931 }
14932 }
14933
14934 mod ___detail {
14935 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
14936 where
14937 ___T: ::fidl_next::Transport,
14938 {
14939 type Client = DictionaryKeysIteratorClient<___T>;
14940 type Server = DictionaryKeysIteratorServer<___T>;
14941 }
14942
14943 #[repr(transparent)]
14945 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
14946 #[allow(dead_code)]
14947 client: ::fidl_next::protocol::Client<___T>,
14948 }
14949
14950 impl<___T> DictionaryKeysIteratorClient<___T>
14951 where
14952 ___T: ::fidl_next::Transport,
14953 {
14954 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
14955 ::fidl_next::TwoWayFuture::from_untyped(
14956 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14957 4987781442555247955,
14958 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
14959 (),
14960 ),
14961 )
14962 }
14963 }
14964
14965 #[repr(transparent)]
14967 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
14968 server: ::fidl_next::protocol::Server<___T>,
14969 }
14970
14971 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
14972 }
14973}
14974
14975#[diagnostic::on_unimplemented(
14976 note = "If {Self} implements the non-local DictionaryKeysIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
14977)]
14978
14979pub trait DictionaryKeysIteratorLocalClientHandler<
14983 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14984 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
14985>
14986{
14987 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
14988 ::core::future::ready(())
14989 }
14990}
14991
14992impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DictionaryKeysIterator
14993where
14994 ___H: DictionaryKeysIteratorLocalClientHandler<___T>,
14995 ___T: ::fidl_next::Transport,
14996{
14997 async fn on_event(
14998 handler: &mut ___H,
14999 mut message: ::fidl_next::Message<___T>,
15000 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15001 match *message.header().ordinal {
15002 ordinal => {
15003 handler.on_unknown_interaction(ordinal).await;
15004 if ::core::matches!(
15005 message.header().flexibility(),
15006 ::fidl_next::protocol::Flexibility::Strict
15007 ) {
15008 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15009 } else {
15010 Ok(())
15011 }
15012 }
15013 }
15014 }
15015}
15016
15017#[diagnostic::on_unimplemented(
15018 note = "If {Self} implements the non-local DictionaryKeysIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15019)]
15020
15021pub trait DictionaryKeysIteratorLocalServerHandler<
15025 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15026 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15027>
15028{
15029 fn get_next(
15030 &mut self,
15031
15032 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
15033 ) -> impl ::core::future::Future<Output = ()>;
15034
15035 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15036 ::core::future::ready(())
15037 }
15038}
15039
15040impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DictionaryKeysIterator
15041where
15042 ___H: DictionaryKeysIteratorLocalServerHandler<___T>,
15043 ___T: ::fidl_next::Transport,
15044{
15045 async fn on_one_way(
15046 handler: &mut ___H,
15047 mut message: ::fidl_next::Message<___T>,
15048 ) -> ::core::result::Result<
15049 (),
15050 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15051 > {
15052 match *message.header().ordinal {
15053 ordinal => {
15054 handler.on_unknown_interaction(ordinal).await;
15055 if ::core::matches!(
15056 message.header().flexibility(),
15057 ::fidl_next::protocol::Flexibility::Strict
15058 ) {
15059 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15060 } else {
15061 Ok(())
15062 }
15063 }
15064 }
15065 }
15066
15067 async fn on_two_way(
15068 handler: &mut ___H,
15069 mut message: ::fidl_next::Message<___T>,
15070 responder: ::fidl_next::protocol::Responder<___T>,
15071 ) -> ::core::result::Result<
15072 (),
15073 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15074 > {
15075 match *message.header().ordinal {
15076 4987781442555247955 => {
15077 let responder = ::fidl_next::Responder::from_untyped(responder);
15078
15079 handler.get_next(responder).await;
15080 Ok(())
15081 }
15082
15083 ordinal => {
15084 handler.on_unknown_interaction(ordinal).await;
15085 if ::core::matches!(
15086 message.header().flexibility(),
15087 ::fidl_next::protocol::Flexibility::Strict
15088 ) {
15089 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15090 } else {
15091 responder
15092 .respond_framework_error(
15093 ordinal,
15094 ::fidl_next::FrameworkError::UnknownMethod,
15095 )
15096 .expect("encoding a framework error should never fail")
15097 .await?;
15098 Ok(())
15099 }
15100 }
15101 }
15102 }
15103}
15104
15105pub trait DictionaryKeysIteratorClientHandler<
15109 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15110 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15111>
15112{
15113 fn on_unknown_interaction(
15114 &mut self,
15115 ordinal: u64,
15116 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15117 ::core::future::ready(())
15118 }
15119}
15120
15121impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
15122where
15123 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
15124 ___T: ::fidl_next::Transport,
15125{
15126 async fn on_event(
15127 handler: &mut ___H,
15128 mut message: ::fidl_next::Message<___T>,
15129 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15130 match *message.header().ordinal {
15131 ordinal => {
15132 handler.on_unknown_interaction(ordinal).await;
15133 if ::core::matches!(
15134 message.header().flexibility(),
15135 ::fidl_next::protocol::Flexibility::Strict
15136 ) {
15137 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15138 } else {
15139 Ok(())
15140 }
15141 }
15142 }
15143 }
15144}
15145
15146pub trait DictionaryKeysIteratorServerHandler<
15150 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15151 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15152>
15153{
15154 fn get_next(
15155 &mut self,
15156
15157 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
15158 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15159
15160 fn on_unknown_interaction(
15161 &mut self,
15162 ordinal: u64,
15163 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15164 ::core::future::ready(())
15165 }
15166}
15167
15168impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
15169where
15170 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
15171 ___T: ::fidl_next::Transport,
15172{
15173 async fn on_one_way(
15174 handler: &mut ___H,
15175 mut message: ::fidl_next::Message<___T>,
15176 ) -> ::core::result::Result<
15177 (),
15178 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15179 > {
15180 match *message.header().ordinal {
15181 ordinal => {
15182 handler.on_unknown_interaction(ordinal).await;
15183 if ::core::matches!(
15184 message.header().flexibility(),
15185 ::fidl_next::protocol::Flexibility::Strict
15186 ) {
15187 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15188 } else {
15189 Ok(())
15190 }
15191 }
15192 }
15193 }
15194
15195 async fn on_two_way(
15196 handler: &mut ___H,
15197 mut message: ::fidl_next::Message<___T>,
15198 responder: ::fidl_next::protocol::Responder<___T>,
15199 ) -> ::core::result::Result<
15200 (),
15201 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15202 > {
15203 match *message.header().ordinal {
15204 4987781442555247955 => {
15205 let responder = ::fidl_next::Responder::from_untyped(responder);
15206
15207 handler.get_next(responder).await;
15208 Ok(())
15209 }
15210
15211 ordinal => {
15212 handler.on_unknown_interaction(ordinal).await;
15213 if ::core::matches!(
15214 message.header().flexibility(),
15215 ::fidl_next::protocol::Flexibility::Strict
15216 ) {
15217 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15218 } else {
15219 responder
15220 .respond_framework_error(
15221 ordinal,
15222 ::fidl_next::FrameworkError::UnknownMethod,
15223 )
15224 .expect("encoding a framework error should never fail")
15225 .await?;
15226 Ok(())
15227 }
15228 }
15229 }
15230 }
15231}
15232
15233impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
15234where
15235 ___T: ::fidl_next::Transport,
15236{
15237 async fn on_unknown_interaction(&mut self, _: u64) {}
15238}
15239
15240impl<___H, ___T> DictionaryKeysIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
15241where
15242 ___H: DictionaryKeysIteratorClientHandler<___T>,
15243 ___T: ::fidl_next::Transport,
15244{
15245 async fn on_unknown_interaction(&mut self, ordinal: u64) {
15246 ___H::on_unknown_interaction(&mut self.0, ordinal).await
15247 }
15248}
15249
15250impl<___H, ___T> DictionaryKeysIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
15251where
15252 ___H: DictionaryKeysIteratorServerHandler<___T>,
15253 ___T: ::fidl_next::Transport,
15254{
15255 async fn get_next(
15256 &mut self,
15257
15258 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
15259 ) {
15260 ___H::get_next(&mut self.0, responder).await
15261 }
15262
15263 async fn on_unknown_interaction(&mut self, ordinal: u64) {
15264 ___H::on_unknown_interaction(&mut self.0, ordinal).await
15265 }
15266}
15267
15268#[derive(PartialEq, Debug)]
15270pub struct DictionaryRouter;
15271
15272impl ::fidl_next::Discoverable for DictionaryRouter {
15273 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
15274}
15275
15276#[cfg(target_os = "fuchsia")]
15277impl ::fidl_next::HasTransport for DictionaryRouter {
15278 type Transport = ::fidl_next::fuchsia::zx::Channel;
15279}
15280
15281pub mod dictionary_router {
15282 pub mod prelude {
15283 pub use crate::{
15284 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterLocalClientHandler,
15285 DictionaryRouterLocalServerHandler, DictionaryRouterServerHandler, dictionary_router,
15286 };
15287
15288 pub use crate::natural::DictionaryRouterRouteResponse;
15289
15290 pub use crate::natural::RouteRequest;
15291
15292 pub use crate::natural::RouterError;
15293 }
15294
15295 pub struct Route;
15296
15297 impl ::fidl_next::Method for Route {
15298 const ORDINAL: u64 = 8164012099375978399;
15299 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
15300 ::fidl_next::protocol::Flexibility::Flexible;
15301
15302 type Protocol = crate::DictionaryRouter;
15303
15304 type Request = crate::wire::RouteRequest<'static>;
15305 }
15306
15307 impl ::fidl_next::TwoWayMethod for Route {
15308 type Response = ::fidl_next::wire::Result<
15309 'static,
15310 crate::wire::DictionaryRouterRouteResponse,
15311 crate::wire::RouterError,
15312 >;
15313 }
15314
15315 impl<___R> ::fidl_next::Respond<___R> for Route {
15316 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
15317
15318 fn respond(response: ___R) -> Self::Output {
15319 ::core::result::Result::Ok(response)
15320 }
15321 }
15322
15323 impl<___R> ::fidl_next::RespondErr<___R> for Route {
15324 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
15325
15326 fn respond_err(response: ___R) -> Self::Output {
15327 ::core::result::Result::Err(response)
15328 }
15329 }
15330
15331 mod ___detail {
15332 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
15333 where
15334 ___T: ::fidl_next::Transport,
15335 {
15336 type Client = DictionaryRouterClient<___T>;
15337 type Server = DictionaryRouterServer<___T>;
15338 }
15339
15340 #[repr(transparent)]
15342 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
15343 #[allow(dead_code)]
15344 client: ::fidl_next::protocol::Client<___T>,
15345 }
15346
15347 impl<___T> DictionaryRouterClient<___T>
15348 where
15349 ___T: ::fidl_next::Transport,
15350 {
15351 pub fn route_with<___R>(
15352 &self,
15353 request: ___R,
15354 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
15355 where
15356 ___R: ::fidl_next::Encode<
15357 crate::wire::RouteRequest<'static>,
15358 <___T as ::fidl_next::Transport>::SendBuffer,
15359 >,
15360 {
15361 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15362 8164012099375978399,
15363 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
15364 request,
15365 ))
15366 }
15367 }
15368
15369 #[repr(transparent)]
15371 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
15372 server: ::fidl_next::protocol::Server<___T>,
15373 }
15374
15375 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
15376 }
15377}
15378
15379#[diagnostic::on_unimplemented(
15380 note = "If {Self} implements the non-local DictionaryRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15381)]
15382
15383pub trait DictionaryRouterLocalClientHandler<
15387 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15388 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15389>
15390{
15391 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15392 ::core::future::ready(())
15393 }
15394}
15395
15396impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DictionaryRouter
15397where
15398 ___H: DictionaryRouterLocalClientHandler<___T>,
15399 ___T: ::fidl_next::Transport,
15400{
15401 async fn on_event(
15402 handler: &mut ___H,
15403 mut message: ::fidl_next::Message<___T>,
15404 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15405 match *message.header().ordinal {
15406 ordinal => {
15407 handler.on_unknown_interaction(ordinal).await;
15408 if ::core::matches!(
15409 message.header().flexibility(),
15410 ::fidl_next::protocol::Flexibility::Strict
15411 ) {
15412 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15413 } else {
15414 Ok(())
15415 }
15416 }
15417 }
15418 }
15419}
15420
15421#[diagnostic::on_unimplemented(
15422 note = "If {Self} implements the non-local DictionaryRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15423)]
15424
15425pub trait DictionaryRouterLocalServerHandler<
15429 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15430 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15431>
15432{
15433 fn route(
15434 &mut self,
15435
15436 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
15437
15438 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
15439 ) -> impl ::core::future::Future<Output = ()>;
15440
15441 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15442 ::core::future::ready(())
15443 }
15444}
15445
15446impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DictionaryRouter
15447where
15448 ___H: DictionaryRouterLocalServerHandler<___T>,
15449 ___T: ::fidl_next::Transport,
15450 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
15451 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15452 Constraint = (),
15453 >,
15454{
15455 async fn on_one_way(
15456 handler: &mut ___H,
15457 mut message: ::fidl_next::Message<___T>,
15458 ) -> ::core::result::Result<
15459 (),
15460 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15461 > {
15462 match *message.header().ordinal {
15463 ordinal => {
15464 handler.on_unknown_interaction(ordinal).await;
15465 if ::core::matches!(
15466 message.header().flexibility(),
15467 ::fidl_next::protocol::Flexibility::Strict
15468 ) {
15469 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15470 } else {
15471 Ok(())
15472 }
15473 }
15474 }
15475 }
15476
15477 async fn on_two_way(
15478 handler: &mut ___H,
15479 mut message: ::fidl_next::Message<___T>,
15480 responder: ::fidl_next::protocol::Responder<___T>,
15481 ) -> ::core::result::Result<
15482 (),
15483 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15484 > {
15485 match *message.header().ordinal {
15486 8164012099375978399 => {
15487 let responder = ::fidl_next::Responder::from_untyped(responder);
15488
15489 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15490 Ok(decoded) => {
15491 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
15492 Ok(())
15493 }
15494 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15495 ordinal: 8164012099375978399,
15496 error,
15497 }),
15498 }
15499 }
15500
15501 ordinal => {
15502 handler.on_unknown_interaction(ordinal).await;
15503 if ::core::matches!(
15504 message.header().flexibility(),
15505 ::fidl_next::protocol::Flexibility::Strict
15506 ) {
15507 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15508 } else {
15509 responder
15510 .respond_framework_error(
15511 ordinal,
15512 ::fidl_next::FrameworkError::UnknownMethod,
15513 )
15514 .expect("encoding a framework error should never fail")
15515 .await?;
15516 Ok(())
15517 }
15518 }
15519 }
15520 }
15521}
15522
15523pub trait DictionaryRouterClientHandler<
15527 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15528 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15529>
15530{
15531 fn on_unknown_interaction(
15532 &mut self,
15533 ordinal: u64,
15534 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15535 ::core::future::ready(())
15536 }
15537}
15538
15539impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
15540where
15541 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
15542 ___T: ::fidl_next::Transport,
15543{
15544 async fn on_event(
15545 handler: &mut ___H,
15546 mut message: ::fidl_next::Message<___T>,
15547 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15548 match *message.header().ordinal {
15549 ordinal => {
15550 handler.on_unknown_interaction(ordinal).await;
15551 if ::core::matches!(
15552 message.header().flexibility(),
15553 ::fidl_next::protocol::Flexibility::Strict
15554 ) {
15555 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15556 } else {
15557 Ok(())
15558 }
15559 }
15560 }
15561 }
15562}
15563
15564pub trait DictionaryRouterServerHandler<
15568 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15569 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15570>
15571{
15572 fn route(
15573 &mut self,
15574
15575 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
15576
15577 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
15578 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15579
15580 fn on_unknown_interaction(
15581 &mut self,
15582 ordinal: u64,
15583 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15584 ::core::future::ready(())
15585 }
15586}
15587
15588impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
15589where
15590 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
15591 ___T: ::fidl_next::Transport,
15592 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
15593 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15594 Constraint = (),
15595 >,
15596{
15597 async fn on_one_way(
15598 handler: &mut ___H,
15599 mut message: ::fidl_next::Message<___T>,
15600 ) -> ::core::result::Result<
15601 (),
15602 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15603 > {
15604 match *message.header().ordinal {
15605 ordinal => {
15606 handler.on_unknown_interaction(ordinal).await;
15607 if ::core::matches!(
15608 message.header().flexibility(),
15609 ::fidl_next::protocol::Flexibility::Strict
15610 ) {
15611 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15612 } else {
15613 Ok(())
15614 }
15615 }
15616 }
15617 }
15618
15619 async fn on_two_way(
15620 handler: &mut ___H,
15621 mut message: ::fidl_next::Message<___T>,
15622 responder: ::fidl_next::protocol::Responder<___T>,
15623 ) -> ::core::result::Result<
15624 (),
15625 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15626 > {
15627 match *message.header().ordinal {
15628 8164012099375978399 => {
15629 let responder = ::fidl_next::Responder::from_untyped(responder);
15630
15631 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15632 Ok(decoded) => {
15633 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
15634 Ok(())
15635 }
15636 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15637 ordinal: 8164012099375978399,
15638 error,
15639 }),
15640 }
15641 }
15642
15643 ordinal => {
15644 handler.on_unknown_interaction(ordinal).await;
15645 if ::core::matches!(
15646 message.header().flexibility(),
15647 ::fidl_next::protocol::Flexibility::Strict
15648 ) {
15649 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15650 } else {
15651 responder
15652 .respond_framework_error(
15653 ordinal,
15654 ::fidl_next::FrameworkError::UnknownMethod,
15655 )
15656 .expect("encoding a framework error should never fail")
15657 .await?;
15658 Ok(())
15659 }
15660 }
15661 }
15662 }
15663}
15664
15665impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
15666where
15667 ___T: ::fidl_next::Transport,
15668{
15669 async fn on_unknown_interaction(&mut self, _: u64) {}
15670}
15671
15672impl<___H, ___T> DictionaryRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
15673where
15674 ___H: DictionaryRouterClientHandler<___T>,
15675 ___T: ::fidl_next::Transport,
15676{
15677 async fn on_unknown_interaction(&mut self, ordinal: u64) {
15678 ___H::on_unknown_interaction(&mut self.0, ordinal).await
15679 }
15680}
15681
15682impl<___H, ___T> DictionaryRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
15683where
15684 ___H: DictionaryRouterServerHandler<___T>,
15685 ___T: ::fidl_next::Transport,
15686{
15687 async fn route(
15688 &mut self,
15689
15690 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
15691
15692 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
15693 ) {
15694 ___H::route(&mut self.0, request, responder).await
15695 }
15696
15697 async fn on_unknown_interaction(&mut self, ordinal: u64) {
15698 ___H::on_unknown_interaction(&mut self.0, ordinal).await
15699 }
15700}
15701
15702#[derive(PartialEq, Debug)]
15704pub struct DirConnectorRouter;
15705
15706impl ::fidl_next::Discoverable for DirConnectorRouter {
15707 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
15708}
15709
15710#[cfg(target_os = "fuchsia")]
15711impl ::fidl_next::HasTransport for DirConnectorRouter {
15712 type Transport = ::fidl_next::fuchsia::zx::Channel;
15713}
15714
15715pub mod dir_connector_router {
15716 pub mod prelude {
15717 pub use crate::{
15718 DirConnectorRouter, DirConnectorRouterClientHandler,
15719 DirConnectorRouterLocalClientHandler, DirConnectorRouterLocalServerHandler,
15720 DirConnectorRouterServerHandler, dir_connector_router,
15721 };
15722
15723 pub use crate::natural::DirConnectorRouterRouteResponse;
15724
15725 pub use crate::natural::RouteRequest;
15726
15727 pub use crate::natural::RouterError;
15728 }
15729
15730 pub struct Route;
15731
15732 impl ::fidl_next::Method for Route {
15733 const ORDINAL: u64 = 972231070188342848;
15734 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
15735 ::fidl_next::protocol::Flexibility::Flexible;
15736
15737 type Protocol = crate::DirConnectorRouter;
15738
15739 type Request = crate::wire::RouteRequest<'static>;
15740 }
15741
15742 impl ::fidl_next::TwoWayMethod for Route {
15743 type Response = ::fidl_next::wire::Result<
15744 'static,
15745 crate::wire::DirConnectorRouterRouteResponse,
15746 crate::wire::RouterError,
15747 >;
15748 }
15749
15750 impl<___R> ::fidl_next::Respond<___R> for Route {
15751 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
15752
15753 fn respond(response: ___R) -> Self::Output {
15754 ::core::result::Result::Ok(response)
15755 }
15756 }
15757
15758 impl<___R> ::fidl_next::RespondErr<___R> for Route {
15759 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
15760
15761 fn respond_err(response: ___R) -> Self::Output {
15762 ::core::result::Result::Err(response)
15763 }
15764 }
15765
15766 mod ___detail {
15767 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
15768 where
15769 ___T: ::fidl_next::Transport,
15770 {
15771 type Client = DirConnectorRouterClient<___T>;
15772 type Server = DirConnectorRouterServer<___T>;
15773 }
15774
15775 #[repr(transparent)]
15777 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
15778 #[allow(dead_code)]
15779 client: ::fidl_next::protocol::Client<___T>,
15780 }
15781
15782 impl<___T> DirConnectorRouterClient<___T>
15783 where
15784 ___T: ::fidl_next::Transport,
15785 {
15786 pub fn route_with<___R>(
15787 &self,
15788 request: ___R,
15789 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
15790 where
15791 ___R: ::fidl_next::Encode<
15792 crate::wire::RouteRequest<'static>,
15793 <___T as ::fidl_next::Transport>::SendBuffer,
15794 >,
15795 {
15796 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15797 972231070188342848,
15798 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
15799 request,
15800 ))
15801 }
15802 }
15803
15804 #[repr(transparent)]
15806 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
15807 server: ::fidl_next::protocol::Server<___T>,
15808 }
15809
15810 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
15811 }
15812}
15813
15814#[diagnostic::on_unimplemented(
15815 note = "If {Self} implements the non-local DirConnectorRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15816)]
15817
15818pub trait DirConnectorRouterLocalClientHandler<
15822 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15823 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15824>
15825{
15826 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15827 ::core::future::ready(())
15828 }
15829}
15830
15831impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirConnectorRouter
15832where
15833 ___H: DirConnectorRouterLocalClientHandler<___T>,
15834 ___T: ::fidl_next::Transport,
15835{
15836 async fn on_event(
15837 handler: &mut ___H,
15838 mut message: ::fidl_next::Message<___T>,
15839 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15840 match *message.header().ordinal {
15841 ordinal => {
15842 handler.on_unknown_interaction(ordinal).await;
15843 if ::core::matches!(
15844 message.header().flexibility(),
15845 ::fidl_next::protocol::Flexibility::Strict
15846 ) {
15847 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15848 } else {
15849 Ok(())
15850 }
15851 }
15852 }
15853 }
15854}
15855
15856#[diagnostic::on_unimplemented(
15857 note = "If {Self} implements the non-local DirConnectorRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15858)]
15859
15860pub trait DirConnectorRouterLocalServerHandler<
15864 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15865 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15866>
15867{
15868 fn route(
15869 &mut self,
15870
15871 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
15872
15873 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
15874 ) -> impl ::core::future::Future<Output = ()>;
15875
15876 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15877 ::core::future::ready(())
15878 }
15879}
15880
15881impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirConnectorRouter
15882where
15883 ___H: DirConnectorRouterLocalServerHandler<___T>,
15884 ___T: ::fidl_next::Transport,
15885 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
15886 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15887 Constraint = (),
15888 >,
15889{
15890 async fn on_one_way(
15891 handler: &mut ___H,
15892 mut message: ::fidl_next::Message<___T>,
15893 ) -> ::core::result::Result<
15894 (),
15895 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15896 > {
15897 match *message.header().ordinal {
15898 ordinal => {
15899 handler.on_unknown_interaction(ordinal).await;
15900 if ::core::matches!(
15901 message.header().flexibility(),
15902 ::fidl_next::protocol::Flexibility::Strict
15903 ) {
15904 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15905 } else {
15906 Ok(())
15907 }
15908 }
15909 }
15910 }
15911
15912 async fn on_two_way(
15913 handler: &mut ___H,
15914 mut message: ::fidl_next::Message<___T>,
15915 responder: ::fidl_next::protocol::Responder<___T>,
15916 ) -> ::core::result::Result<
15917 (),
15918 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15919 > {
15920 match *message.header().ordinal {
15921 972231070188342848 => {
15922 let responder = ::fidl_next::Responder::from_untyped(responder);
15923
15924 match ::fidl_next::AsDecoderExt::into_decoded(message) {
15925 Ok(decoded) => {
15926 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
15927 Ok(())
15928 }
15929 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15930 ordinal: 972231070188342848,
15931 error,
15932 }),
15933 }
15934 }
15935
15936 ordinal => {
15937 handler.on_unknown_interaction(ordinal).await;
15938 if ::core::matches!(
15939 message.header().flexibility(),
15940 ::fidl_next::protocol::Flexibility::Strict
15941 ) {
15942 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15943 } else {
15944 responder
15945 .respond_framework_error(
15946 ordinal,
15947 ::fidl_next::FrameworkError::UnknownMethod,
15948 )
15949 .expect("encoding a framework error should never fail")
15950 .await?;
15951 Ok(())
15952 }
15953 }
15954 }
15955 }
15956}
15957
15958pub trait DirConnectorRouterClientHandler<
15962 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15963 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15964>
15965{
15966 fn on_unknown_interaction(
15967 &mut self,
15968 ordinal: u64,
15969 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
15970 ::core::future::ready(())
15971 }
15972}
15973
15974impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
15975where
15976 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
15977 ___T: ::fidl_next::Transport,
15978{
15979 async fn on_event(
15980 handler: &mut ___H,
15981 mut message: ::fidl_next::Message<___T>,
15982 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15983 match *message.header().ordinal {
15984 ordinal => {
15985 handler.on_unknown_interaction(ordinal).await;
15986 if ::core::matches!(
15987 message.header().flexibility(),
15988 ::fidl_next::protocol::Flexibility::Strict
15989 ) {
15990 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15991 } else {
15992 Ok(())
15993 }
15994 }
15995 }
15996 }
15997}
15998
15999pub trait DirConnectorRouterServerHandler<
16003 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16004 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16005>
16006{
16007 fn route(
16008 &mut self,
16009
16010 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
16011
16012 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
16013 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16014
16015 fn on_unknown_interaction(
16016 &mut self,
16017 ordinal: u64,
16018 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16019 ::core::future::ready(())
16020 }
16021}
16022
16023impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
16024where
16025 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
16026 ___T: ::fidl_next::Transport,
16027 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
16028 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16029 Constraint = (),
16030 >,
16031{
16032 async fn on_one_way(
16033 handler: &mut ___H,
16034 mut message: ::fidl_next::Message<___T>,
16035 ) -> ::core::result::Result<
16036 (),
16037 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16038 > {
16039 match *message.header().ordinal {
16040 ordinal => {
16041 handler.on_unknown_interaction(ordinal).await;
16042 if ::core::matches!(
16043 message.header().flexibility(),
16044 ::fidl_next::protocol::Flexibility::Strict
16045 ) {
16046 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16047 } else {
16048 Ok(())
16049 }
16050 }
16051 }
16052 }
16053
16054 async fn on_two_way(
16055 handler: &mut ___H,
16056 mut message: ::fidl_next::Message<___T>,
16057 responder: ::fidl_next::protocol::Responder<___T>,
16058 ) -> ::core::result::Result<
16059 (),
16060 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16061 > {
16062 match *message.header().ordinal {
16063 972231070188342848 => {
16064 let responder = ::fidl_next::Responder::from_untyped(responder);
16065
16066 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16067 Ok(decoded) => {
16068 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
16069 Ok(())
16070 }
16071 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16072 ordinal: 972231070188342848,
16073 error,
16074 }),
16075 }
16076 }
16077
16078 ordinal => {
16079 handler.on_unknown_interaction(ordinal).await;
16080 if ::core::matches!(
16081 message.header().flexibility(),
16082 ::fidl_next::protocol::Flexibility::Strict
16083 ) {
16084 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16085 } else {
16086 responder
16087 .respond_framework_error(
16088 ordinal,
16089 ::fidl_next::FrameworkError::UnknownMethod,
16090 )
16091 .expect("encoding a framework error should never fail")
16092 .await?;
16093 Ok(())
16094 }
16095 }
16096 }
16097 }
16098}
16099
16100impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
16101where
16102 ___T: ::fidl_next::Transport,
16103{
16104 async fn on_unknown_interaction(&mut self, _: u64) {}
16105}
16106
16107impl<___H, ___T> DirConnectorRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
16108where
16109 ___H: DirConnectorRouterClientHandler<___T>,
16110 ___T: ::fidl_next::Transport,
16111{
16112 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16113 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16114 }
16115}
16116
16117impl<___H, ___T> DirConnectorRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
16118where
16119 ___H: DirConnectorRouterServerHandler<___T>,
16120 ___T: ::fidl_next::Transport,
16121{
16122 async fn route(
16123 &mut self,
16124
16125 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
16126
16127 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
16128 ) {
16129 ___H::route(&mut self.0, request, responder).await
16130 }
16131
16132 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16133 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16134 }
16135}
16136
16137#[derive(PartialEq, Debug)]
16139pub struct DirEntryRouter;
16140
16141impl ::fidl_next::Discoverable for DirEntryRouter {
16142 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
16143}
16144
16145#[cfg(target_os = "fuchsia")]
16146impl ::fidl_next::HasTransport for DirEntryRouter {
16147 type Transport = ::fidl_next::fuchsia::zx::Channel;
16148}
16149
16150pub mod dir_entry_router {
16151 pub mod prelude {
16152 pub use crate::{
16153 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterLocalClientHandler,
16154 DirEntryRouterLocalServerHandler, DirEntryRouterServerHandler, dir_entry_router,
16155 };
16156
16157 pub use crate::natural::DirEntryRouterRouteResponse;
16158
16159 pub use crate::natural::RouteRequest;
16160
16161 pub use crate::natural::RouterError;
16162 }
16163
16164 pub struct Route;
16165
16166 impl ::fidl_next::Method for Route {
16167 const ORDINAL: u64 = 1929392218567642066;
16168 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16169 ::fidl_next::protocol::Flexibility::Flexible;
16170
16171 type Protocol = crate::DirEntryRouter;
16172
16173 type Request = crate::wire::RouteRequest<'static>;
16174 }
16175
16176 impl ::fidl_next::TwoWayMethod for Route {
16177 type Response = ::fidl_next::wire::Result<
16178 'static,
16179 crate::wire::DirEntryRouterRouteResponse,
16180 crate::wire::RouterError,
16181 >;
16182 }
16183
16184 impl<___R> ::fidl_next::Respond<___R> for Route {
16185 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
16186
16187 fn respond(response: ___R) -> Self::Output {
16188 ::core::result::Result::Ok(response)
16189 }
16190 }
16191
16192 impl<___R> ::fidl_next::RespondErr<___R> for Route {
16193 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
16194
16195 fn respond_err(response: ___R) -> Self::Output {
16196 ::core::result::Result::Err(response)
16197 }
16198 }
16199
16200 mod ___detail {
16201 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
16202 where
16203 ___T: ::fidl_next::Transport,
16204 {
16205 type Client = DirEntryRouterClient<___T>;
16206 type Server = DirEntryRouterServer<___T>;
16207 }
16208
16209 #[repr(transparent)]
16211 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
16212 #[allow(dead_code)]
16213 client: ::fidl_next::protocol::Client<___T>,
16214 }
16215
16216 impl<___T> DirEntryRouterClient<___T>
16217 where
16218 ___T: ::fidl_next::Transport,
16219 {
16220 pub fn route_with<___R>(
16221 &self,
16222 request: ___R,
16223 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
16224 where
16225 ___R: ::fidl_next::Encode<
16226 crate::wire::RouteRequest<'static>,
16227 <___T as ::fidl_next::Transport>::SendBuffer,
16228 >,
16229 {
16230 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
16231 1929392218567642066,
16232 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
16233 request,
16234 ))
16235 }
16236 }
16237
16238 #[repr(transparent)]
16240 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
16241 server: ::fidl_next::protocol::Server<___T>,
16242 }
16243
16244 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
16245 }
16246}
16247
16248#[diagnostic::on_unimplemented(
16249 note = "If {Self} implements the non-local DirEntryRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
16250)]
16251
16252pub trait DirEntryRouterLocalClientHandler<
16256 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16257 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16258>
16259{
16260 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
16261 ::core::future::ready(())
16262 }
16263}
16264
16265impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirEntryRouter
16266where
16267 ___H: DirEntryRouterLocalClientHandler<___T>,
16268 ___T: ::fidl_next::Transport,
16269{
16270 async fn on_event(
16271 handler: &mut ___H,
16272 mut message: ::fidl_next::Message<___T>,
16273 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16274 match *message.header().ordinal {
16275 ordinal => {
16276 handler.on_unknown_interaction(ordinal).await;
16277 if ::core::matches!(
16278 message.header().flexibility(),
16279 ::fidl_next::protocol::Flexibility::Strict
16280 ) {
16281 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16282 } else {
16283 Ok(())
16284 }
16285 }
16286 }
16287 }
16288}
16289
16290#[diagnostic::on_unimplemented(
16291 note = "If {Self} implements the non-local DirEntryRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
16292)]
16293
16294pub trait DirEntryRouterLocalServerHandler<
16298 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16299 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16300>
16301{
16302 fn route(
16303 &mut self,
16304
16305 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
16306
16307 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
16308 ) -> impl ::core::future::Future<Output = ()>;
16309
16310 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
16311 ::core::future::ready(())
16312 }
16313}
16314
16315impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirEntryRouter
16316where
16317 ___H: DirEntryRouterLocalServerHandler<___T>,
16318 ___T: ::fidl_next::Transport,
16319 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
16320 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16321 Constraint = (),
16322 >,
16323{
16324 async fn on_one_way(
16325 handler: &mut ___H,
16326 mut message: ::fidl_next::Message<___T>,
16327 ) -> ::core::result::Result<
16328 (),
16329 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16330 > {
16331 match *message.header().ordinal {
16332 ordinal => {
16333 handler.on_unknown_interaction(ordinal).await;
16334 if ::core::matches!(
16335 message.header().flexibility(),
16336 ::fidl_next::protocol::Flexibility::Strict
16337 ) {
16338 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16339 } else {
16340 Ok(())
16341 }
16342 }
16343 }
16344 }
16345
16346 async fn on_two_way(
16347 handler: &mut ___H,
16348 mut message: ::fidl_next::Message<___T>,
16349 responder: ::fidl_next::protocol::Responder<___T>,
16350 ) -> ::core::result::Result<
16351 (),
16352 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16353 > {
16354 match *message.header().ordinal {
16355 1929392218567642066 => {
16356 let responder = ::fidl_next::Responder::from_untyped(responder);
16357
16358 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16359 Ok(decoded) => {
16360 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
16361 Ok(())
16362 }
16363 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16364 ordinal: 1929392218567642066,
16365 error,
16366 }),
16367 }
16368 }
16369
16370 ordinal => {
16371 handler.on_unknown_interaction(ordinal).await;
16372 if ::core::matches!(
16373 message.header().flexibility(),
16374 ::fidl_next::protocol::Flexibility::Strict
16375 ) {
16376 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16377 } else {
16378 responder
16379 .respond_framework_error(
16380 ordinal,
16381 ::fidl_next::FrameworkError::UnknownMethod,
16382 )
16383 .expect("encoding a framework error should never fail")
16384 .await?;
16385 Ok(())
16386 }
16387 }
16388 }
16389 }
16390}
16391
16392pub trait DirEntryRouterClientHandler<
16396 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16397 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16398>
16399{
16400 fn on_unknown_interaction(
16401 &mut self,
16402 ordinal: u64,
16403 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16404 ::core::future::ready(())
16405 }
16406}
16407
16408impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
16409where
16410 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
16411 ___T: ::fidl_next::Transport,
16412{
16413 async fn on_event(
16414 handler: &mut ___H,
16415 mut message: ::fidl_next::Message<___T>,
16416 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16417 match *message.header().ordinal {
16418 ordinal => {
16419 handler.on_unknown_interaction(ordinal).await;
16420 if ::core::matches!(
16421 message.header().flexibility(),
16422 ::fidl_next::protocol::Flexibility::Strict
16423 ) {
16424 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16425 } else {
16426 Ok(())
16427 }
16428 }
16429 }
16430 }
16431}
16432
16433pub trait DirEntryRouterServerHandler<
16437 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16438 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16439>
16440{
16441 fn route(
16442 &mut self,
16443
16444 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
16445
16446 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
16447 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16448
16449 fn on_unknown_interaction(
16450 &mut self,
16451 ordinal: u64,
16452 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16453 ::core::future::ready(())
16454 }
16455}
16456
16457impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
16458where
16459 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
16460 ___T: ::fidl_next::Transport,
16461 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
16462 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16463 Constraint = (),
16464 >,
16465{
16466 async fn on_one_way(
16467 handler: &mut ___H,
16468 mut message: ::fidl_next::Message<___T>,
16469 ) -> ::core::result::Result<
16470 (),
16471 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16472 > {
16473 match *message.header().ordinal {
16474 ordinal => {
16475 handler.on_unknown_interaction(ordinal).await;
16476 if ::core::matches!(
16477 message.header().flexibility(),
16478 ::fidl_next::protocol::Flexibility::Strict
16479 ) {
16480 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16481 } else {
16482 Ok(())
16483 }
16484 }
16485 }
16486 }
16487
16488 async fn on_two_way(
16489 handler: &mut ___H,
16490 mut message: ::fidl_next::Message<___T>,
16491 responder: ::fidl_next::protocol::Responder<___T>,
16492 ) -> ::core::result::Result<
16493 (),
16494 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16495 > {
16496 match *message.header().ordinal {
16497 1929392218567642066 => {
16498 let responder = ::fidl_next::Responder::from_untyped(responder);
16499
16500 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16501 Ok(decoded) => {
16502 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
16503 Ok(())
16504 }
16505 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16506 ordinal: 1929392218567642066,
16507 error,
16508 }),
16509 }
16510 }
16511
16512 ordinal => {
16513 handler.on_unknown_interaction(ordinal).await;
16514 if ::core::matches!(
16515 message.header().flexibility(),
16516 ::fidl_next::protocol::Flexibility::Strict
16517 ) {
16518 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16519 } else {
16520 responder
16521 .respond_framework_error(
16522 ordinal,
16523 ::fidl_next::FrameworkError::UnknownMethod,
16524 )
16525 .expect("encoding a framework error should never fail")
16526 .await?;
16527 Ok(())
16528 }
16529 }
16530 }
16531 }
16532}
16533
16534impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
16535where
16536 ___T: ::fidl_next::Transport,
16537{
16538 async fn on_unknown_interaction(&mut self, _: u64) {}
16539}
16540
16541impl<___H, ___T> DirEntryRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
16542where
16543 ___H: DirEntryRouterClientHandler<___T>,
16544 ___T: ::fidl_next::Transport,
16545{
16546 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16547 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16548 }
16549}
16550
16551impl<___H, ___T> DirEntryRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
16552where
16553 ___H: DirEntryRouterServerHandler<___T>,
16554 ___T: ::fidl_next::Transport,
16555{
16556 async fn route(
16557 &mut self,
16558
16559 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
16560
16561 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
16562 ) {
16563 ___H::route(&mut self.0, request, responder).await
16564 }
16565
16566 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16567 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16568 }
16569}
16570
16571#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
16573#[derive(PartialEq, Debug)]
16574pub struct DirReceiver;
16575
16576impl ::fidl_next::Discoverable for DirReceiver {
16577 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
16578}
16579
16580#[cfg(target_os = "fuchsia")]
16581impl ::fidl_next::HasTransport for DirReceiver {
16582 type Transport = ::fidl_next::fuchsia::zx::Channel;
16583}
16584
16585pub mod dir_receiver {
16586 pub mod prelude {
16587 pub use crate::{
16588 DirReceiver, DirReceiverClientHandler, DirReceiverLocalClientHandler,
16589 DirReceiverLocalServerHandler, DirReceiverServerHandler, dir_receiver,
16590 };
16591
16592 pub use crate::natural::DirReceiverReceiveRequest;
16593 }
16594
16595 pub struct Receive;
16596
16597 impl ::fidl_next::Method for Receive {
16598 const ORDINAL: u64 = 926684461087488948;
16599 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16600 ::fidl_next::protocol::Flexibility::Flexible;
16601
16602 type Protocol = crate::DirReceiver;
16603
16604 type Request = crate::wire::DirReceiverReceiveRequest<'static>;
16605 }
16606
16607 mod ___detail {
16608 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
16609 where
16610 ___T: ::fidl_next::Transport,
16611 {
16612 type Client = DirReceiverClient<___T>;
16613 type Server = DirReceiverServer<___T>;
16614 }
16615
16616 #[repr(transparent)]
16618 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
16619 #[allow(dead_code)]
16620 client: ::fidl_next::protocol::Client<___T>,
16621 }
16622
16623 impl<___T> DirReceiverClient<___T>
16624 where
16625 ___T: ::fidl_next::Transport,
16626 {
16627 #[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"]
16628 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
16629 where
16630 ___R: ::fidl_next::Encode<
16631 crate::wire::DirReceiverReceiveRequest<'static>,
16632 <___T as ::fidl_next::Transport>::SendBuffer,
16633 >,
16634 {
16635 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
16636 926684461087488948,
16637 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
16638 request,
16639 ))
16640 }
16641 }
16642
16643 #[repr(transparent)]
16645 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
16646 server: ::fidl_next::protocol::Server<___T>,
16647 }
16648
16649 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
16650 }
16651}
16652
16653#[diagnostic::on_unimplemented(
16654 note = "If {Self} implements the non-local DirReceiverClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
16655)]
16656
16657pub trait DirReceiverLocalClientHandler<
16661 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16662 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16663>
16664{
16665 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
16666 ::core::future::ready(())
16667 }
16668}
16669
16670impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirReceiver
16671where
16672 ___H: DirReceiverLocalClientHandler<___T>,
16673 ___T: ::fidl_next::Transport,
16674{
16675 async fn on_event(
16676 handler: &mut ___H,
16677 mut message: ::fidl_next::Message<___T>,
16678 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16679 match *message.header().ordinal {
16680 ordinal => {
16681 handler.on_unknown_interaction(ordinal).await;
16682 if ::core::matches!(
16683 message.header().flexibility(),
16684 ::fidl_next::protocol::Flexibility::Strict
16685 ) {
16686 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16687 } else {
16688 Ok(())
16689 }
16690 }
16691 }
16692 }
16693}
16694
16695#[diagnostic::on_unimplemented(
16696 note = "If {Self} implements the non-local DirReceiverServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
16697)]
16698
16699pub trait DirReceiverLocalServerHandler<
16703 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16704 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16705>
16706{
16707 #[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"]
16708 fn receive(
16709 &mut self,
16710
16711 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
16712 ) -> impl ::core::future::Future<Output = ()>;
16713
16714 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
16715 ::core::future::ready(())
16716 }
16717}
16718
16719impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirReceiver
16720where
16721 ___H: DirReceiverLocalServerHandler<___T>,
16722 ___T: ::fidl_next::Transport,
16723 for<'de> crate::wire::DirReceiverReceiveRequest<'de>: ::fidl_next::Decode<
16724 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16725 Constraint = (),
16726 >,
16727{
16728 async fn on_one_way(
16729 handler: &mut ___H,
16730 mut message: ::fidl_next::Message<___T>,
16731 ) -> ::core::result::Result<
16732 (),
16733 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16734 > {
16735 match *message.header().ordinal {
16736 926684461087488948 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16737 Ok(decoded) => {
16738 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
16739 Ok(())
16740 }
16741 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16742 ordinal: 926684461087488948,
16743 error,
16744 }),
16745 },
16746
16747 ordinal => {
16748 handler.on_unknown_interaction(ordinal).await;
16749 if ::core::matches!(
16750 message.header().flexibility(),
16751 ::fidl_next::protocol::Flexibility::Strict
16752 ) {
16753 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16754 } else {
16755 Ok(())
16756 }
16757 }
16758 }
16759 }
16760
16761 async fn on_two_way(
16762 handler: &mut ___H,
16763 mut message: ::fidl_next::Message<___T>,
16764 responder: ::fidl_next::protocol::Responder<___T>,
16765 ) -> ::core::result::Result<
16766 (),
16767 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16768 > {
16769 match *message.header().ordinal {
16770 ordinal => {
16771 handler.on_unknown_interaction(ordinal).await;
16772 if ::core::matches!(
16773 message.header().flexibility(),
16774 ::fidl_next::protocol::Flexibility::Strict
16775 ) {
16776 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16777 } else {
16778 responder
16779 .respond_framework_error(
16780 ordinal,
16781 ::fidl_next::FrameworkError::UnknownMethod,
16782 )
16783 .expect("encoding a framework error should never fail")
16784 .await?;
16785 Ok(())
16786 }
16787 }
16788 }
16789 }
16790}
16791
16792pub trait DirReceiverClientHandler<
16796 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16797 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16798>
16799{
16800 fn on_unknown_interaction(
16801 &mut self,
16802 ordinal: u64,
16803 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16804 ::core::future::ready(())
16805 }
16806}
16807
16808impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
16809where
16810 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
16811 ___T: ::fidl_next::Transport,
16812{
16813 async fn on_event(
16814 handler: &mut ___H,
16815 mut message: ::fidl_next::Message<___T>,
16816 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16817 match *message.header().ordinal {
16818 ordinal => {
16819 handler.on_unknown_interaction(ordinal).await;
16820 if ::core::matches!(
16821 message.header().flexibility(),
16822 ::fidl_next::protocol::Flexibility::Strict
16823 ) {
16824 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16825 } else {
16826 Ok(())
16827 }
16828 }
16829 }
16830 }
16831}
16832
16833pub trait DirReceiverServerHandler<
16837 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16838 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16839>
16840{
16841 #[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"]
16842 fn receive(
16843 &mut self,
16844
16845 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
16846 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16847
16848 fn on_unknown_interaction(
16849 &mut self,
16850 ordinal: u64,
16851 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16852 ::core::future::ready(())
16853 }
16854}
16855
16856impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
16857where
16858 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
16859 ___T: ::fidl_next::Transport,
16860 for<'de> crate::wire::DirReceiverReceiveRequest<'de>: ::fidl_next::Decode<
16861 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16862 Constraint = (),
16863 >,
16864{
16865 async fn on_one_way(
16866 handler: &mut ___H,
16867 mut message: ::fidl_next::Message<___T>,
16868 ) -> ::core::result::Result<
16869 (),
16870 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16871 > {
16872 match *message.header().ordinal {
16873 926684461087488948 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16874 Ok(decoded) => {
16875 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
16876 Ok(())
16877 }
16878 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16879 ordinal: 926684461087488948,
16880 error,
16881 }),
16882 },
16883
16884 ordinal => {
16885 handler.on_unknown_interaction(ordinal).await;
16886 if ::core::matches!(
16887 message.header().flexibility(),
16888 ::fidl_next::protocol::Flexibility::Strict
16889 ) {
16890 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16891 } else {
16892 Ok(())
16893 }
16894 }
16895 }
16896 }
16897
16898 async fn on_two_way(
16899 handler: &mut ___H,
16900 mut message: ::fidl_next::Message<___T>,
16901 responder: ::fidl_next::protocol::Responder<___T>,
16902 ) -> ::core::result::Result<
16903 (),
16904 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16905 > {
16906 match *message.header().ordinal {
16907 ordinal => {
16908 handler.on_unknown_interaction(ordinal).await;
16909 if ::core::matches!(
16910 message.header().flexibility(),
16911 ::fidl_next::protocol::Flexibility::Strict
16912 ) {
16913 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16914 } else {
16915 responder
16916 .respond_framework_error(
16917 ordinal,
16918 ::fidl_next::FrameworkError::UnknownMethod,
16919 )
16920 .expect("encoding a framework error should never fail")
16921 .await?;
16922 Ok(())
16923 }
16924 }
16925 }
16926 }
16927}
16928
16929impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
16930where
16931 ___T: ::fidl_next::Transport,
16932{
16933 async fn on_unknown_interaction(&mut self, _: u64) {}
16934}
16935
16936impl<___H, ___T> DirReceiverLocalClientHandler<___T> for ::fidl_next::Local<___H>
16937where
16938 ___H: DirReceiverClientHandler<___T>,
16939 ___T: ::fidl_next::Transport,
16940{
16941 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16942 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16943 }
16944}
16945
16946impl<___H, ___T> DirReceiverLocalServerHandler<___T> for ::fidl_next::Local<___H>
16947where
16948 ___H: DirReceiverServerHandler<___T>,
16949 ___T: ::fidl_next::Transport,
16950{
16951 async fn receive(&mut self, request: ::fidl_next::Request<dir_receiver::Receive, ___T>) {
16952 ___H::receive(&mut self.0, request).await
16953 }
16954
16955 async fn on_unknown_interaction(&mut self, ordinal: u64) {
16956 ___H::on_unknown_interaction(&mut self.0, ordinal).await
16957 }
16958}
16959
16960#[derive(PartialEq, Debug)]
16962pub struct DirectoryRouter;
16963
16964impl ::fidl_next::Discoverable for DirectoryRouter {
16965 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
16966}
16967
16968#[cfg(target_os = "fuchsia")]
16969impl ::fidl_next::HasTransport for DirectoryRouter {
16970 type Transport = ::fidl_next::fuchsia::zx::Channel;
16971}
16972
16973pub mod directory_router {
16974 pub mod prelude {
16975 pub use crate::{
16976 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterLocalClientHandler,
16977 DirectoryRouterLocalServerHandler, DirectoryRouterServerHandler, directory_router,
16978 };
16979
16980 pub use crate::natural::DirectoryRouterRouteResponse;
16981
16982 pub use crate::natural::RouteRequest;
16983
16984 pub use crate::natural::RouterError;
16985 }
16986
16987 pub struct Route;
16988
16989 impl ::fidl_next::Method for Route {
16990 const ORDINAL: u64 = 7510716014181158689;
16991 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16992 ::fidl_next::protocol::Flexibility::Flexible;
16993
16994 type Protocol = crate::DirectoryRouter;
16995
16996 type Request = crate::wire::RouteRequest<'static>;
16997 }
16998
16999 impl ::fidl_next::TwoWayMethod for Route {
17000 type Response = ::fidl_next::wire::Result<
17001 'static,
17002 crate::wire::DirectoryRouterRouteResponse,
17003 crate::wire::RouterError,
17004 >;
17005 }
17006
17007 impl<___R> ::fidl_next::Respond<___R> for Route {
17008 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17009
17010 fn respond(response: ___R) -> Self::Output {
17011 ::core::result::Result::Ok(response)
17012 }
17013 }
17014
17015 impl<___R> ::fidl_next::RespondErr<___R> for Route {
17016 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17017
17018 fn respond_err(response: ___R) -> Self::Output {
17019 ::core::result::Result::Err(response)
17020 }
17021 }
17022
17023 mod ___detail {
17024 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
17025 where
17026 ___T: ::fidl_next::Transport,
17027 {
17028 type Client = DirectoryRouterClient<___T>;
17029 type Server = DirectoryRouterServer<___T>;
17030 }
17031
17032 #[repr(transparent)]
17034 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
17035 #[allow(dead_code)]
17036 client: ::fidl_next::protocol::Client<___T>,
17037 }
17038
17039 impl<___T> DirectoryRouterClient<___T>
17040 where
17041 ___T: ::fidl_next::Transport,
17042 {
17043 pub fn route_with<___R>(
17044 &self,
17045 request: ___R,
17046 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
17047 where
17048 ___R: ::fidl_next::Encode<
17049 crate::wire::RouteRequest<'static>,
17050 <___T as ::fidl_next::Transport>::SendBuffer,
17051 >,
17052 {
17053 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17054 7510716014181158689,
17055 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
17056 request,
17057 ))
17058 }
17059 }
17060
17061 #[repr(transparent)]
17063 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
17064 server: ::fidl_next::protocol::Server<___T>,
17065 }
17066
17067 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
17068 }
17069}
17070
17071#[diagnostic::on_unimplemented(
17072 note = "If {Self} implements the non-local DirectoryRouterClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
17073)]
17074
17075pub trait DirectoryRouterLocalClientHandler<
17079 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17080 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17081>
17082{
17083 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
17084 ::core::future::ready(())
17085 }
17086}
17087
17088impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirectoryRouter
17089where
17090 ___H: DirectoryRouterLocalClientHandler<___T>,
17091 ___T: ::fidl_next::Transport,
17092{
17093 async fn on_event(
17094 handler: &mut ___H,
17095 mut message: ::fidl_next::Message<___T>,
17096 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17097 match *message.header().ordinal {
17098 ordinal => {
17099 handler.on_unknown_interaction(ordinal).await;
17100 if ::core::matches!(
17101 message.header().flexibility(),
17102 ::fidl_next::protocol::Flexibility::Strict
17103 ) {
17104 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17105 } else {
17106 Ok(())
17107 }
17108 }
17109 }
17110 }
17111}
17112
17113#[diagnostic::on_unimplemented(
17114 note = "If {Self} implements the non-local DirectoryRouterServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
17115)]
17116
17117pub trait DirectoryRouterLocalServerHandler<
17121 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17122 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17123>
17124{
17125 fn route(
17126 &mut self,
17127
17128 request: ::fidl_next::Request<directory_router::Route, ___T>,
17129
17130 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
17131 ) -> impl ::core::future::Future<Output = ()>;
17132
17133 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
17134 ::core::future::ready(())
17135 }
17136}
17137
17138impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirectoryRouter
17139where
17140 ___H: DirectoryRouterLocalServerHandler<___T>,
17141 ___T: ::fidl_next::Transport,
17142 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
17143 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17144 Constraint = (),
17145 >,
17146{
17147 async fn on_one_way(
17148 handler: &mut ___H,
17149 mut message: ::fidl_next::Message<___T>,
17150 ) -> ::core::result::Result<
17151 (),
17152 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17153 > {
17154 match *message.header().ordinal {
17155 ordinal => {
17156 handler.on_unknown_interaction(ordinal).await;
17157 if ::core::matches!(
17158 message.header().flexibility(),
17159 ::fidl_next::protocol::Flexibility::Strict
17160 ) {
17161 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17162 } else {
17163 Ok(())
17164 }
17165 }
17166 }
17167 }
17168
17169 async fn on_two_way(
17170 handler: &mut ___H,
17171 mut message: ::fidl_next::Message<___T>,
17172 responder: ::fidl_next::protocol::Responder<___T>,
17173 ) -> ::core::result::Result<
17174 (),
17175 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17176 > {
17177 match *message.header().ordinal {
17178 7510716014181158689 => {
17179 let responder = ::fidl_next::Responder::from_untyped(responder);
17180
17181 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17182 Ok(decoded) => {
17183 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
17184 Ok(())
17185 }
17186 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17187 ordinal: 7510716014181158689,
17188 error,
17189 }),
17190 }
17191 }
17192
17193 ordinal => {
17194 handler.on_unknown_interaction(ordinal).await;
17195 if ::core::matches!(
17196 message.header().flexibility(),
17197 ::fidl_next::protocol::Flexibility::Strict
17198 ) {
17199 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17200 } else {
17201 responder
17202 .respond_framework_error(
17203 ordinal,
17204 ::fidl_next::FrameworkError::UnknownMethod,
17205 )
17206 .expect("encoding a framework error should never fail")
17207 .await?;
17208 Ok(())
17209 }
17210 }
17211 }
17212 }
17213}
17214
17215pub trait DirectoryRouterClientHandler<
17219 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17220 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17221>
17222{
17223 fn on_unknown_interaction(
17224 &mut self,
17225 ordinal: u64,
17226 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17227 ::core::future::ready(())
17228 }
17229}
17230
17231impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
17232where
17233 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
17234 ___T: ::fidl_next::Transport,
17235{
17236 async fn on_event(
17237 handler: &mut ___H,
17238 mut message: ::fidl_next::Message<___T>,
17239 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17240 match *message.header().ordinal {
17241 ordinal => {
17242 handler.on_unknown_interaction(ordinal).await;
17243 if ::core::matches!(
17244 message.header().flexibility(),
17245 ::fidl_next::protocol::Flexibility::Strict
17246 ) {
17247 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17248 } else {
17249 Ok(())
17250 }
17251 }
17252 }
17253 }
17254}
17255
17256pub trait DirectoryRouterServerHandler<
17260 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17261 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17262>
17263{
17264 fn route(
17265 &mut self,
17266
17267 request: ::fidl_next::Request<directory_router::Route, ___T>,
17268
17269 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
17270 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17271
17272 fn on_unknown_interaction(
17273 &mut self,
17274 ordinal: u64,
17275 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17276 ::core::future::ready(())
17277 }
17278}
17279
17280impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
17281where
17282 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
17283 ___T: ::fidl_next::Transport,
17284 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
17285 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17286 Constraint = (),
17287 >,
17288{
17289 async fn on_one_way(
17290 handler: &mut ___H,
17291 mut message: ::fidl_next::Message<___T>,
17292 ) -> ::core::result::Result<
17293 (),
17294 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17295 > {
17296 match *message.header().ordinal {
17297 ordinal => {
17298 handler.on_unknown_interaction(ordinal).await;
17299 if ::core::matches!(
17300 message.header().flexibility(),
17301 ::fidl_next::protocol::Flexibility::Strict
17302 ) {
17303 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17304 } else {
17305 Ok(())
17306 }
17307 }
17308 }
17309 }
17310
17311 async fn on_two_way(
17312 handler: &mut ___H,
17313 mut message: ::fidl_next::Message<___T>,
17314 responder: ::fidl_next::protocol::Responder<___T>,
17315 ) -> ::core::result::Result<
17316 (),
17317 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17318 > {
17319 match *message.header().ordinal {
17320 7510716014181158689 => {
17321 let responder = ::fidl_next::Responder::from_untyped(responder);
17322
17323 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17324 Ok(decoded) => {
17325 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
17326 Ok(())
17327 }
17328 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17329 ordinal: 7510716014181158689,
17330 error,
17331 }),
17332 }
17333 }
17334
17335 ordinal => {
17336 handler.on_unknown_interaction(ordinal).await;
17337 if ::core::matches!(
17338 message.header().flexibility(),
17339 ::fidl_next::protocol::Flexibility::Strict
17340 ) {
17341 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17342 } else {
17343 responder
17344 .respond_framework_error(
17345 ordinal,
17346 ::fidl_next::FrameworkError::UnknownMethod,
17347 )
17348 .expect("encoding a framework error should never fail")
17349 .await?;
17350 Ok(())
17351 }
17352 }
17353 }
17354 }
17355}
17356
17357impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
17358where
17359 ___T: ::fidl_next::Transport,
17360{
17361 async fn on_unknown_interaction(&mut self, _: u64) {}
17362}
17363
17364impl<___H, ___T> DirectoryRouterLocalClientHandler<___T> for ::fidl_next::Local<___H>
17365where
17366 ___H: DirectoryRouterClientHandler<___T>,
17367 ___T: ::fidl_next::Transport,
17368{
17369 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17370 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17371 }
17372}
17373
17374impl<___H, ___T> DirectoryRouterLocalServerHandler<___T> for ::fidl_next::Local<___H>
17375where
17376 ___H: DirectoryRouterServerHandler<___T>,
17377 ___T: ::fidl_next::Transport,
17378{
17379 async fn route(
17380 &mut self,
17381
17382 request: ::fidl_next::Request<directory_router::Route, ___T>,
17383
17384 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
17385 ) {
17386 ___H::route(&mut self.0, request, responder).await
17387 }
17388
17389 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17390 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17391 }
17392}
17393
17394#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
17396#[derive(PartialEq, Debug)]
17397pub struct Receiver;
17398
17399impl ::fidl_next::Discoverable for Receiver {
17400 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
17401}
17402
17403#[cfg(target_os = "fuchsia")]
17404impl ::fidl_next::HasTransport for Receiver {
17405 type Transport = ::fidl_next::fuchsia::zx::Channel;
17406}
17407
17408pub mod receiver {
17409 pub mod prelude {
17410 pub use crate::{
17411 Receiver, ReceiverClientHandler, ReceiverLocalClientHandler,
17412 ReceiverLocalServerHandler, ReceiverServerHandler, receiver,
17413 };
17414
17415 pub use crate::natural::ProtocolPayload;
17416 }
17417
17418 pub struct Receive;
17419
17420 impl ::fidl_next::Method for Receive {
17421 const ORDINAL: u64 = 340832707723008660;
17422 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17423 ::fidl_next::protocol::Flexibility::Flexible;
17424
17425 type Protocol = crate::Receiver;
17426
17427 type Request = crate::wire::ProtocolPayload;
17428 }
17429
17430 mod ___detail {
17431 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
17432 where
17433 ___T: ::fidl_next::Transport,
17434 {
17435 type Client = ReceiverClient<___T>;
17436 type Server = ReceiverServer<___T>;
17437 }
17438
17439 #[repr(transparent)]
17441 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
17442 #[allow(dead_code)]
17443 client: ::fidl_next::protocol::Client<___T>,
17444 }
17445
17446 impl<___T> ReceiverClient<___T>
17447 where
17448 ___T: ::fidl_next::Transport,
17449 {
17450 #[doc = " Sends a channel to this receiver.\n"]
17451 pub fn receive(
17452 &self,
17453
17454 channel: impl ::fidl_next::Encode<
17455 ::fidl_next::wire::fuchsia::Channel,
17456 <___T as ::fidl_next::Transport>::SendBuffer,
17457 >,
17458 ) -> ::fidl_next::SendFuture<'_, ___T>
17459 where
17460 <___T as ::fidl_next::Transport>::SendBuffer:
17461 ::fidl_next::encoder::InternalHandleEncoder,
17462 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17463 {
17464 self.receive_with(crate::generic::ProtocolPayload { channel })
17465 }
17466
17467 #[doc = " Sends a channel to this receiver.\n"]
17468 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
17469 where
17470 ___R: ::fidl_next::Encode<
17471 crate::wire::ProtocolPayload,
17472 <___T as ::fidl_next::Transport>::SendBuffer,
17473 >,
17474 {
17475 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
17476 340832707723008660,
17477 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
17478 request,
17479 ))
17480 }
17481 }
17482
17483 #[repr(transparent)]
17485 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
17486 server: ::fidl_next::protocol::Server<___T>,
17487 }
17488
17489 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
17490 }
17491}
17492
17493#[diagnostic::on_unimplemented(
17494 note = "If {Self} implements the non-local ReceiverClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
17495)]
17496
17497pub trait ReceiverLocalClientHandler<
17501 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17502 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17503>
17504{
17505 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
17506 ::core::future::ready(())
17507 }
17508}
17509
17510impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Receiver
17511where
17512 ___H: ReceiverLocalClientHandler<___T>,
17513 ___T: ::fidl_next::Transport,
17514{
17515 async fn on_event(
17516 handler: &mut ___H,
17517 mut message: ::fidl_next::Message<___T>,
17518 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17519 match *message.header().ordinal {
17520 ordinal => {
17521 handler.on_unknown_interaction(ordinal).await;
17522 if ::core::matches!(
17523 message.header().flexibility(),
17524 ::fidl_next::protocol::Flexibility::Strict
17525 ) {
17526 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17527 } else {
17528 Ok(())
17529 }
17530 }
17531 }
17532 }
17533}
17534
17535#[diagnostic::on_unimplemented(
17536 note = "If {Self} implements the non-local ReceiverServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
17537)]
17538
17539pub trait ReceiverLocalServerHandler<
17543 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17544 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17545>
17546{
17547 #[doc = " Sends a channel to this receiver.\n"]
17548 fn receive(
17549 &mut self,
17550
17551 request: ::fidl_next::Request<receiver::Receive, ___T>,
17552 ) -> impl ::core::future::Future<Output = ()>;
17553
17554 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
17555 ::core::future::ready(())
17556 }
17557}
17558
17559impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Receiver
17560where
17561 ___H: ReceiverLocalServerHandler<___T>,
17562 ___T: ::fidl_next::Transport,
17563 for<'de> crate::wire::ProtocolPayload: ::fidl_next::Decode<
17564 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17565 Constraint = (),
17566 >,
17567{
17568 async fn on_one_way(
17569 handler: &mut ___H,
17570 mut message: ::fidl_next::Message<___T>,
17571 ) -> ::core::result::Result<
17572 (),
17573 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17574 > {
17575 match *message.header().ordinal {
17576 340832707723008660 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
17577 Ok(decoded) => {
17578 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
17579 Ok(())
17580 }
17581 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17582 ordinal: 340832707723008660,
17583 error,
17584 }),
17585 },
17586
17587 ordinal => {
17588 handler.on_unknown_interaction(ordinal).await;
17589 if ::core::matches!(
17590 message.header().flexibility(),
17591 ::fidl_next::protocol::Flexibility::Strict
17592 ) {
17593 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17594 } else {
17595 Ok(())
17596 }
17597 }
17598 }
17599 }
17600
17601 async fn on_two_way(
17602 handler: &mut ___H,
17603 mut message: ::fidl_next::Message<___T>,
17604 responder: ::fidl_next::protocol::Responder<___T>,
17605 ) -> ::core::result::Result<
17606 (),
17607 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17608 > {
17609 match *message.header().ordinal {
17610 ordinal => {
17611 handler.on_unknown_interaction(ordinal).await;
17612 if ::core::matches!(
17613 message.header().flexibility(),
17614 ::fidl_next::protocol::Flexibility::Strict
17615 ) {
17616 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17617 } else {
17618 responder
17619 .respond_framework_error(
17620 ordinal,
17621 ::fidl_next::FrameworkError::UnknownMethod,
17622 )
17623 .expect("encoding a framework error should never fail")
17624 .await?;
17625 Ok(())
17626 }
17627 }
17628 }
17629 }
17630}
17631
17632pub trait ReceiverClientHandler<
17636 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17637 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17638>
17639{
17640 fn on_unknown_interaction(
17641 &mut self,
17642 ordinal: u64,
17643 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17644 ::core::future::ready(())
17645 }
17646}
17647
17648impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
17649where
17650 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
17651 ___T: ::fidl_next::Transport,
17652{
17653 async fn on_event(
17654 handler: &mut ___H,
17655 mut message: ::fidl_next::Message<___T>,
17656 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17657 match *message.header().ordinal {
17658 ordinal => {
17659 handler.on_unknown_interaction(ordinal).await;
17660 if ::core::matches!(
17661 message.header().flexibility(),
17662 ::fidl_next::protocol::Flexibility::Strict
17663 ) {
17664 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17665 } else {
17666 Ok(())
17667 }
17668 }
17669 }
17670 }
17671}
17672
17673pub trait ReceiverServerHandler<
17677 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17678 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17679>
17680{
17681 #[doc = " Sends a channel to this receiver.\n"]
17682 fn receive(
17683 &mut self,
17684
17685 request: ::fidl_next::Request<receiver::Receive, ___T>,
17686 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17687
17688 fn on_unknown_interaction(
17689 &mut self,
17690 ordinal: u64,
17691 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17692 ::core::future::ready(())
17693 }
17694}
17695
17696impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
17697where
17698 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
17699 ___T: ::fidl_next::Transport,
17700 for<'de> crate::wire::ProtocolPayload: ::fidl_next::Decode<
17701 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17702 Constraint = (),
17703 >,
17704{
17705 async fn on_one_way(
17706 handler: &mut ___H,
17707 mut message: ::fidl_next::Message<___T>,
17708 ) -> ::core::result::Result<
17709 (),
17710 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17711 > {
17712 match *message.header().ordinal {
17713 340832707723008660 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
17714 Ok(decoded) => {
17715 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
17716 Ok(())
17717 }
17718 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17719 ordinal: 340832707723008660,
17720 error,
17721 }),
17722 },
17723
17724 ordinal => {
17725 handler.on_unknown_interaction(ordinal).await;
17726 if ::core::matches!(
17727 message.header().flexibility(),
17728 ::fidl_next::protocol::Flexibility::Strict
17729 ) {
17730 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17731 } else {
17732 Ok(())
17733 }
17734 }
17735 }
17736 }
17737
17738 async fn on_two_way(
17739 handler: &mut ___H,
17740 mut message: ::fidl_next::Message<___T>,
17741 responder: ::fidl_next::protocol::Responder<___T>,
17742 ) -> ::core::result::Result<
17743 (),
17744 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17745 > {
17746 match *message.header().ordinal {
17747 ordinal => {
17748 handler.on_unknown_interaction(ordinal).await;
17749 if ::core::matches!(
17750 message.header().flexibility(),
17751 ::fidl_next::protocol::Flexibility::Strict
17752 ) {
17753 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17754 } else {
17755 responder
17756 .respond_framework_error(
17757 ordinal,
17758 ::fidl_next::FrameworkError::UnknownMethod,
17759 )
17760 .expect("encoding a framework error should never fail")
17761 .await?;
17762 Ok(())
17763 }
17764 }
17765 }
17766 }
17767}
17768
17769impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
17770where
17771 ___T: ::fidl_next::Transport,
17772{
17773 async fn on_unknown_interaction(&mut self, _: u64) {}
17774}
17775
17776impl<___H, ___T> ReceiverLocalClientHandler<___T> for ::fidl_next::Local<___H>
17777where
17778 ___H: ReceiverClientHandler<___T>,
17779 ___T: ::fidl_next::Transport,
17780{
17781 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17782 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17783 }
17784}
17785
17786impl<___H, ___T> ReceiverLocalServerHandler<___T> for ::fidl_next::Local<___H>
17787where
17788 ___H: ReceiverServerHandler<___T>,
17789 ___T: ::fidl_next::Transport,
17790{
17791 async fn receive(&mut self, request: ::fidl_next::Request<receiver::Receive, ___T>) {
17792 ___H::receive(&mut self.0, request).await
17793 }
17794
17795 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17796 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17797 }
17798}
17799
17800pub use fidl_next_common_fuchsia_component_sandbox::*;