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 pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
2140 }
2141
2142 impl RouteRequest {
2143 fn __max_ordinal(&self) -> usize {
2144 if self.metadata.is_some() {
2145 return 2;
2146 }
2147
2148 if self.requesting.is_some() {
2149 return 1;
2150 }
2151
2152 0
2153 }
2154 }
2155
2156 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouteRequest<'static>, ___E> for RouteRequest
2157 where
2158 ___E: ::fidl_next::Encoder + ?Sized,
2159 ___E: ::fidl_next::fuchsia::HandleEncoder,
2160 {
2161 #[inline]
2162 fn encode(
2163 mut self,
2164 encoder: &mut ___E,
2165 out: &mut ::core::mem::MaybeUninit<crate::wire::RouteRequest<'static>>,
2166 _: (),
2167 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2168 ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
2169
2170 let max_ord = self.__max_ordinal();
2171
2172 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2173 ::fidl_next::Wire::zero_padding(&mut out);
2174
2175 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2176 ::fidl_next::wire::Envelope,
2177 >(encoder, max_ord);
2178
2179 for i in 1..=max_ord {
2180 match i {
2181 2 => {
2182 if let Some(value) = self.metadata.take() {
2183 ::fidl_next::wire::Envelope::encode_value::<
2184 crate::wire::DictionaryRef,
2185 ___E,
2186 >(
2187 value, preallocated.encoder, &mut out, ()
2188 )?;
2189 } else {
2190 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2191 }
2192 }
2193
2194 1 => {
2195 if let Some(value) = self.requesting.take() {
2196 ::fidl_next::wire::Envelope::encode_value::<
2197 crate::wire::InstanceToken,
2198 ___E,
2199 >(
2200 value, preallocated.encoder, &mut out, ()
2201 )?;
2202 } else {
2203 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2204 }
2205 }
2206
2207 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2208 }
2209 unsafe {
2210 preallocated.write_next(out.assume_init_ref());
2211 }
2212 }
2213
2214 ::fidl_next::wire::Table::encode_len(table, max_ord);
2215
2216 Ok(())
2217 }
2218 }
2219
2220 impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
2221 #[inline]
2222 fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
2223 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2224
2225 let requesting = wire_.table.get(1);
2226
2227 let metadata = wire_.table.get(2);
2228
2229 Self {
2230 requesting: requesting.map(|envelope| {
2231 ::fidl_next::FromWire::from_wire(unsafe {
2232 envelope.read_unchecked::<crate::wire::InstanceToken>()
2233 })
2234 }),
2235
2236 metadata: metadata.map(|envelope| {
2237 ::fidl_next::FromWire::from_wire(unsafe {
2238 envelope.read_unchecked::<crate::wire::DictionaryRef>()
2239 })
2240 }),
2241 }
2242 }
2243 }
2244
2245 #[derive(Debug, PartialEq)]
2246 pub enum ConnectorRouterRouteResponse {
2247 Connector(crate::natural::Connector),
2248
2249 Unavailable(crate::natural::Unit),
2250 }
2251
2252 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>
2253 for ConnectorRouterRouteResponse
2254 where
2255 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2256 ___E: ::fidl_next::fuchsia::HandleEncoder,
2257 {
2258 #[inline]
2259 fn encode(
2260 self,
2261 encoder: &mut ___E,
2262 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectorRouterRouteResponse>,
2263 _: (),
2264 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2265 ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2266
2267 match self {
2268 Self::Connector(value) => ::fidl_next::wire::Union::encode_as_static::<
2269 ___E,
2270 crate::wire::Connector,
2271 >(value, 1, encoder, raw, ())?,
2272
2273 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2274 ___E,
2275 crate::wire::Unit,
2276 >(value, 2, encoder, raw, ())?,
2277 }
2278
2279 Ok(())
2280 }
2281 }
2282
2283 unsafe impl<___E>
2284 ::fidl_next::EncodeOption<crate::wire_optional::ConnectorRouterRouteResponse, ___E>
2285 for ConnectorRouterRouteResponse
2286 where
2287 ___E: ?Sized,
2288 ConnectorRouterRouteResponse:
2289 ::fidl_next::Encode<crate::wire::ConnectorRouterRouteResponse, ___E>,
2290 {
2291 #[inline]
2292 fn encode_option(
2293 this: ::core::option::Option<Self>,
2294 encoder: &mut ___E,
2295 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::ConnectorRouterRouteResponse>,
2296 _: (),
2297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2298 ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2299
2300 if let Some(inner) = this {
2301 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2302 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2303 } else {
2304 ::fidl_next::wire::Union::encode_absent(raw);
2305 }
2306
2307 Ok(())
2308 }
2309 }
2310
2311 impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
2312 for ConnectorRouterRouteResponse
2313 {
2314 #[inline]
2315 fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
2316 let wire = ::core::mem::ManuallyDrop::new(wire);
2317 match wire.raw.ordinal() {
2318 1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
2319 wire.raw.get().read_unchecked::<crate::wire::Connector>()
2320 })),
2321
2322 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2323 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2324 })),
2325
2326 _ => unsafe { ::core::hint::unreachable_unchecked() },
2327 }
2328 }
2329 }
2330
2331 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2332 for ConnectorRouterRouteResponse
2333 {
2334 #[inline]
2335 fn from_wire_option(
2336 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2337 ) -> ::core::option::Option<Self> {
2338 if let Some(inner) = wire.into_option() {
2339 Some(::fidl_next::FromWire::from_wire(inner))
2340 } else {
2341 None
2342 }
2343 }
2344 }
2345
2346 impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
2347 for Box<ConnectorRouterRouteResponse>
2348 {
2349 #[inline]
2350 fn from_wire_option(
2351 wire: crate::wire_optional::ConnectorRouterRouteResponse,
2352 ) -> ::core::option::Option<Self> {
2353 <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
2354 crate::wire_optional::ConnectorRouterRouteResponse,
2355 >>::from_wire_option(wire)
2356 .map(Box::new)
2357 }
2358 }
2359
2360 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2361 pub enum DataRouterRouteResponse {
2362 Data(crate::natural::Data),
2363
2364 Unavailable(crate::natural::Unit),
2365 }
2366
2367 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>
2368 for DataRouterRouteResponse
2369 where
2370 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2371 ___E: ::fidl_next::Encoder,
2372 ___E: ::fidl_next::fuchsia::HandleEncoder,
2373 {
2374 #[inline]
2375 fn encode(
2376 self,
2377 encoder: &mut ___E,
2378 out: &mut ::core::mem::MaybeUninit<crate::wire::DataRouterRouteResponse<'static>>,
2379 _: (),
2380 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2381 ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
2382
2383 match self {
2384 Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
2385 ___E,
2386 crate::wire::Data<'static>,
2387 >(value, 1, encoder, raw, ())?,
2388
2389 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as::<
2390 ___E,
2391 crate::wire::Unit,
2392 >(value, 2, encoder, raw, ())?,
2393 }
2394
2395 Ok(())
2396 }
2397 }
2398
2399 unsafe impl<___E>
2400 ::fidl_next::EncodeOption<crate::wire_optional::DataRouterRouteResponse<'static>, ___E>
2401 for DataRouterRouteResponse
2402 where
2403 ___E: ?Sized,
2404 DataRouterRouteResponse:
2405 ::fidl_next::Encode<crate::wire::DataRouterRouteResponse<'static>, ___E>,
2406 {
2407 #[inline]
2408 fn encode_option(
2409 this: ::core::option::Option<Self>,
2410 encoder: &mut ___E,
2411 out: &mut ::core::mem::MaybeUninit<
2412 crate::wire_optional::DataRouterRouteResponse<'static>,
2413 >,
2414 _: (),
2415 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2416 ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2417
2418 if let Some(inner) = this {
2419 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2420 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2421 } else {
2422 ::fidl_next::wire::Union::encode_absent(raw);
2423 }
2424
2425 Ok(())
2426 }
2427 }
2428
2429 impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
2430 for DataRouterRouteResponse
2431 {
2432 #[inline]
2433 fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
2434 let wire = ::core::mem::ManuallyDrop::new(wire);
2435 match wire.raw.ordinal() {
2436 1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
2437 wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
2438 })),
2439
2440 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2441 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2442 })),
2443
2444 _ => unsafe { ::core::hint::unreachable_unchecked() },
2445 }
2446 }
2447 }
2448
2449 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2450 for DataRouterRouteResponse
2451 {
2452 #[inline]
2453 fn from_wire_option(
2454 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2455 ) -> ::core::option::Option<Self> {
2456 if let Some(inner) = wire.into_option() {
2457 Some(::fidl_next::FromWire::from_wire(inner))
2458 } else {
2459 None
2460 }
2461 }
2462 }
2463
2464 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
2465 for Box<DataRouterRouteResponse>
2466 {
2467 #[inline]
2468 fn from_wire_option(
2469 wire: crate::wire_optional::DataRouterRouteResponse<'de>,
2470 ) -> ::core::option::Option<Self> {
2471 <DataRouterRouteResponse as ::fidl_next::FromWireOption<
2472 crate::wire_optional::DataRouterRouteResponse<'de>,
2473 >>::from_wire_option(wire)
2474 .map(Box::new)
2475 }
2476 }
2477
2478 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2479 pub struct DictionaryDrainIteratorGetNextResponse {
2480 pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
2481
2482 pub end_id: u64,
2483 }
2484
2485 unsafe impl<___E>
2486 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
2487 for DictionaryDrainIteratorGetNextResponse
2488 where
2489 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2490 ___E: ::fidl_next::Encoder,
2491 ___E: ::fidl_next::fuchsia::HandleEncoder,
2492 {
2493 #[inline]
2494 fn encode(
2495 self,
2496 encoder_: &mut ___E,
2497 out_: &mut ::core::mem::MaybeUninit<
2498 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2499 >,
2500 _: (),
2501 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2502 ::fidl_next::munge! {
2503 let crate::wire::DictionaryDrainIteratorGetNextResponse {
2504 items,
2505 end_id,
2506
2507 } = out_;
2508 }
2509
2510 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2511
2512 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2513 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2514
2515 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2516
2517 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2518
2519 Ok(())
2520 }
2521 }
2522
2523 unsafe impl<___E>
2524 ::fidl_next::EncodeOption<
2525 ::fidl_next::wire::Box<
2526 'static,
2527 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2528 >,
2529 ___E,
2530 > for DictionaryDrainIteratorGetNextResponse
2531 where
2532 ___E: ::fidl_next::Encoder + ?Sized,
2533 DictionaryDrainIteratorGetNextResponse:
2534 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>,
2535 {
2536 #[inline]
2537 fn encode_option(
2538 this: ::core::option::Option<Self>,
2539 encoder: &mut ___E,
2540 out: &mut ::core::mem::MaybeUninit<
2541 ::fidl_next::wire::Box<
2542 'static,
2543 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
2544 >,
2545 >,
2546 _: (),
2547 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2548 if let Some(inner) = this {
2549 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2550 ::fidl_next::wire::Box::encode_present(out);
2551 } else {
2552 ::fidl_next::wire::Box::encode_absent(out);
2553 }
2554
2555 Ok(())
2556 }
2557 }
2558
2559 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
2560 for DictionaryDrainIteratorGetNextResponse
2561 {
2562 #[inline]
2563 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
2564 Self {
2565 items: ::fidl_next::FromWire::from_wire(wire.items),
2566
2567 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2568 }
2569 }
2570 }
2571
2572 #[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"]
2573 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2574 pub struct DictionaryOptionalItem {
2575 pub key: ::std::string::String,
2576
2577 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
2578 }
2579
2580 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
2581 for DictionaryOptionalItem
2582 where
2583 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2584 ___E: ::fidl_next::Encoder,
2585 ___E: ::fidl_next::fuchsia::HandleEncoder,
2586 {
2587 #[inline]
2588 fn encode(
2589 self,
2590 encoder_: &mut ___E,
2591 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
2592 _: (),
2593 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2594 ::fidl_next::munge! {
2595 let crate::wire::DictionaryOptionalItem {
2596 key,
2597 value,
2598
2599 } = out_;
2600 }
2601
2602 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
2603
2604 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
2605 ::fidl_next::Constrained::validate(_field, 255)?;
2606
2607 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
2608
2609 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
2610
2611 Ok(())
2612 }
2613 }
2614
2615 unsafe impl<___E>
2616 ::fidl_next::EncodeOption<
2617 ::fidl_next::wire::Box<'static, crate::wire::DictionaryOptionalItem<'static>>,
2618 ___E,
2619 > for DictionaryOptionalItem
2620 where
2621 ___E: ::fidl_next::Encoder + ?Sized,
2622 DictionaryOptionalItem:
2623 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>,
2624 {
2625 #[inline]
2626 fn encode_option(
2627 this: ::core::option::Option<Self>,
2628 encoder: &mut ___E,
2629 out: &mut ::core::mem::MaybeUninit<
2630 ::fidl_next::wire::Box<'static, crate::wire::DictionaryOptionalItem<'static>>,
2631 >,
2632 _: (),
2633 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2634 if let Some(inner) = this {
2635 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2636 ::fidl_next::wire::Box::encode_present(out);
2637 } else {
2638 ::fidl_next::wire::Box::encode_absent(out);
2639 }
2640
2641 Ok(())
2642 }
2643 }
2644
2645 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
2646 for DictionaryOptionalItem
2647 {
2648 #[inline]
2649 fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
2650 Self {
2651 key: ::fidl_next::FromWire::from_wire(wire.key),
2652
2653 value: ::fidl_next::FromWire::from_wire(wire.value),
2654 }
2655 }
2656 }
2657
2658 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2659 pub struct DictionaryEnumerateIteratorGetNextResponse {
2660 pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
2661
2662 pub end_id: u64,
2663 }
2664
2665 unsafe impl<___E>
2666 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
2667 for DictionaryEnumerateIteratorGetNextResponse
2668 where
2669 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2670 ___E: ::fidl_next::Encoder,
2671 ___E: ::fidl_next::fuchsia::HandleEncoder,
2672 {
2673 #[inline]
2674 fn encode(
2675 self,
2676 encoder_: &mut ___E,
2677 out_: &mut ::core::mem::MaybeUninit<
2678 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2679 >,
2680 _: (),
2681 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2682 ::fidl_next::munge! {
2683 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
2684 items,
2685 end_id,
2686
2687 } = out_;
2688 }
2689
2690 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
2691
2692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
2693 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2694
2695 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
2696
2697 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
2698
2699 Ok(())
2700 }
2701 }
2702
2703 unsafe impl<___E>
2704 ::fidl_next::EncodeOption<
2705 ::fidl_next::wire::Box<
2706 'static,
2707 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2708 >,
2709 ___E,
2710 > for DictionaryEnumerateIteratorGetNextResponse
2711 where
2712 ___E: ::fidl_next::Encoder + ?Sized,
2713 DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<
2714 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2715 ___E,
2716 >,
2717 {
2718 #[inline]
2719 fn encode_option(
2720 this: ::core::option::Option<Self>,
2721 encoder: &mut ___E,
2722 out: &mut ::core::mem::MaybeUninit<
2723 ::fidl_next::wire::Box<
2724 'static,
2725 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
2726 >,
2727 >,
2728 _: (),
2729 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2730 if let Some(inner) = this {
2731 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2732 ::fidl_next::wire::Box::encode_present(out);
2733 } else {
2734 ::fidl_next::wire::Box::encode_absent(out);
2735 }
2736
2737 Ok(())
2738 }
2739 }
2740
2741 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
2742 for DictionaryEnumerateIteratorGetNextResponse
2743 {
2744 #[inline]
2745 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
2746 Self {
2747 items: ::fidl_next::FromWire::from_wire(wire.items),
2748
2749 end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
2750 }
2751 }
2752 }
2753
2754 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2755 pub struct DictionaryKeysIteratorGetNextResponse {
2756 pub keys: ::std::vec::Vec<::std::string::String>,
2757 }
2758
2759 unsafe impl<___E>
2760 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
2761 for DictionaryKeysIteratorGetNextResponse
2762 where
2763 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2764 ___E: ::fidl_next::Encoder,
2765 ___E: ::fidl_next::fuchsia::HandleEncoder,
2766 {
2767 #[inline]
2768 fn encode(
2769 self,
2770 encoder_: &mut ___E,
2771 out_: &mut ::core::mem::MaybeUninit<
2772 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2773 >,
2774 _: (),
2775 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2776 ::fidl_next::munge! {
2777 let crate::wire::DictionaryKeysIteratorGetNextResponse {
2778 keys,
2779
2780 } = out_;
2781 }
2782
2783 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
2784
2785 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
2786 ::fidl_next::Constrained::validate(_field, (128, 255))?;
2787
2788 Ok(())
2789 }
2790 }
2791
2792 unsafe impl<___E>
2793 ::fidl_next::EncodeOption<
2794 ::fidl_next::wire::Box<
2795 'static,
2796 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2797 >,
2798 ___E,
2799 > for DictionaryKeysIteratorGetNextResponse
2800 where
2801 ___E: ::fidl_next::Encoder + ?Sized,
2802 DictionaryKeysIteratorGetNextResponse:
2803 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>,
2804 {
2805 #[inline]
2806 fn encode_option(
2807 this: ::core::option::Option<Self>,
2808 encoder: &mut ___E,
2809 out: &mut ::core::mem::MaybeUninit<
2810 ::fidl_next::wire::Box<
2811 'static,
2812 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
2813 >,
2814 >,
2815 _: (),
2816 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2817 if let Some(inner) = this {
2818 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2819 ::fidl_next::wire::Box::encode_present(out);
2820 } else {
2821 ::fidl_next::wire::Box::encode_absent(out);
2822 }
2823
2824 Ok(())
2825 }
2826 }
2827
2828 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
2829 for DictionaryKeysIteratorGetNextResponse
2830 {
2831 #[inline]
2832 fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
2833 Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
2834 }
2835 }
2836
2837 #[derive(Debug, PartialEq)]
2838 pub enum DictionaryRouterRouteResponse {
2839 Dictionary(crate::natural::DictionaryRef),
2840
2841 Unavailable(crate::natural::Unit),
2842 }
2843
2844 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>
2845 for DictionaryRouterRouteResponse
2846 where
2847 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2848 ___E: ::fidl_next::fuchsia::HandleEncoder,
2849 {
2850 #[inline]
2851 fn encode(
2852 self,
2853 encoder: &mut ___E,
2854 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRouterRouteResponse>,
2855 _: (),
2856 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2857 ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
2858
2859 match self {
2860 Self::Dictionary(value) => ::fidl_next::wire::Union::encode_as_static::<
2861 ___E,
2862 crate::wire::DictionaryRef,
2863 >(value, 1, encoder, raw, ())?,
2864
2865 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2866 ___E,
2867 crate::wire::Unit,
2868 >(value, 2, encoder, raw, ())?,
2869 }
2870
2871 Ok(())
2872 }
2873 }
2874
2875 unsafe impl<___E>
2876 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryRouterRouteResponse, ___E>
2877 for DictionaryRouterRouteResponse
2878 where
2879 ___E: ?Sized,
2880 DictionaryRouterRouteResponse:
2881 ::fidl_next::Encode<crate::wire::DictionaryRouterRouteResponse, ___E>,
2882 {
2883 #[inline]
2884 fn encode_option(
2885 this: ::core::option::Option<Self>,
2886 encoder: &mut ___E,
2887 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryRouterRouteResponse>,
2888 _: (),
2889 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2890 ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
2891
2892 if let Some(inner) = this {
2893 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2894 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2895 } else {
2896 ::fidl_next::wire::Union::encode_absent(raw);
2897 }
2898
2899 Ok(())
2900 }
2901 }
2902
2903 impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
2904 for DictionaryRouterRouteResponse
2905 {
2906 #[inline]
2907 fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
2908 let wire = ::core::mem::ManuallyDrop::new(wire);
2909 match wire.raw.ordinal() {
2910 1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
2911 wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
2912 })),
2913
2914 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
2915 wire.raw.get().read_unchecked::<crate::wire::Unit>()
2916 })),
2917
2918 _ => unsafe { ::core::hint::unreachable_unchecked() },
2919 }
2920 }
2921 }
2922
2923 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2924 for DictionaryRouterRouteResponse
2925 {
2926 #[inline]
2927 fn from_wire_option(
2928 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2929 ) -> ::core::option::Option<Self> {
2930 if let Some(inner) = wire.into_option() {
2931 Some(::fidl_next::FromWire::from_wire(inner))
2932 } else {
2933 None
2934 }
2935 }
2936 }
2937
2938 impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
2939 for Box<DictionaryRouterRouteResponse>
2940 {
2941 #[inline]
2942 fn from_wire_option(
2943 wire: crate::wire_optional::DictionaryRouterRouteResponse,
2944 ) -> ::core::option::Option<Self> {
2945 <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
2946 crate::wire_optional::DictionaryRouterRouteResponse,
2947 >>::from_wire_option(wire)
2948 .map(Box::new)
2949 }
2950 }
2951
2952 #[derive(Debug, PartialEq)]
2953 pub enum DirConnectorRouterRouteResponse {
2954 DirConnector(crate::natural::DirConnector),
2955
2956 Unavailable(crate::natural::Unit),
2957 }
2958
2959 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>
2960 for DirConnectorRouterRouteResponse
2961 where
2962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2963 ___E: ::fidl_next::fuchsia::HandleEncoder,
2964 {
2965 #[inline]
2966 fn encode(
2967 self,
2968 encoder: &mut ___E,
2969 out: &mut ::core::mem::MaybeUninit<crate::wire::DirConnectorRouterRouteResponse>,
2970 _: (),
2971 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2972 ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
2973
2974 match self {
2975 Self::DirConnector(value) => ::fidl_next::wire::Union::encode_as_static::<
2976 ___E,
2977 crate::wire::DirConnector,
2978 >(value, 1, encoder, raw, ())?,
2979
2980 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
2981 ___E,
2982 crate::wire::Unit,
2983 >(value, 2, encoder, raw, ())?,
2984 }
2985
2986 Ok(())
2987 }
2988 }
2989
2990 unsafe impl<___E>
2991 ::fidl_next::EncodeOption<crate::wire_optional::DirConnectorRouterRouteResponse, ___E>
2992 for DirConnectorRouterRouteResponse
2993 where
2994 ___E: ?Sized,
2995 DirConnectorRouterRouteResponse:
2996 ::fidl_next::Encode<crate::wire::DirConnectorRouterRouteResponse, ___E>,
2997 {
2998 #[inline]
2999 fn encode_option(
3000 this: ::core::option::Option<Self>,
3001 encoder: &mut ___E,
3002 out: &mut ::core::mem::MaybeUninit<
3003 crate::wire_optional::DirConnectorRouterRouteResponse,
3004 >,
3005 _: (),
3006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3007 ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3008
3009 if let Some(inner) = this {
3010 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3011 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3012 } else {
3013 ::fidl_next::wire::Union::encode_absent(raw);
3014 }
3015
3016 Ok(())
3017 }
3018 }
3019
3020 impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
3021 for DirConnectorRouterRouteResponse
3022 {
3023 #[inline]
3024 fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
3025 let wire = ::core::mem::ManuallyDrop::new(wire);
3026 match wire.raw.ordinal() {
3027 1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
3028 wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
3029 })),
3030
3031 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3032 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3033 })),
3034
3035 _ => unsafe { ::core::hint::unreachable_unchecked() },
3036 }
3037 }
3038 }
3039
3040 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3041 for DirConnectorRouterRouteResponse
3042 {
3043 #[inline]
3044 fn from_wire_option(
3045 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3046 ) -> ::core::option::Option<Self> {
3047 if let Some(inner) = wire.into_option() {
3048 Some(::fidl_next::FromWire::from_wire(inner))
3049 } else {
3050 None
3051 }
3052 }
3053 }
3054
3055 impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
3056 for Box<DirConnectorRouterRouteResponse>
3057 {
3058 #[inline]
3059 fn from_wire_option(
3060 wire: crate::wire_optional::DirConnectorRouterRouteResponse,
3061 ) -> ::core::option::Option<Self> {
3062 <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
3063 crate::wire_optional::DirConnectorRouterRouteResponse,
3064 >>::from_wire_option(wire)
3065 .map(Box::new)
3066 }
3067 }
3068
3069 #[derive(Debug, PartialEq)]
3070 pub enum DirEntryRouterRouteResponse {
3071 DirEntry(crate::natural::DirEntry),
3072
3073 Unavailable(crate::natural::Unit),
3074 }
3075
3076 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>
3077 for DirEntryRouterRouteResponse
3078 where
3079 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3080 ___E: ::fidl_next::fuchsia::HandleEncoder,
3081 {
3082 #[inline]
3083 fn encode(
3084 self,
3085 encoder: &mut ___E,
3086 out: &mut ::core::mem::MaybeUninit<crate::wire::DirEntryRouterRouteResponse>,
3087 _: (),
3088 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3089 ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
3090
3091 match self {
3092 Self::DirEntry(value) => ::fidl_next::wire::Union::encode_as_static::<
3093 ___E,
3094 crate::wire::DirEntry,
3095 >(value, 1, encoder, raw, ())?,
3096
3097 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
3098 ___E,
3099 crate::wire::Unit,
3100 >(value, 2, encoder, raw, ())?,
3101 }
3102
3103 Ok(())
3104 }
3105 }
3106
3107 unsafe impl<___E>
3108 ::fidl_next::EncodeOption<crate::wire_optional::DirEntryRouterRouteResponse, ___E>
3109 for DirEntryRouterRouteResponse
3110 where
3111 ___E: ?Sized,
3112 DirEntryRouterRouteResponse:
3113 ::fidl_next::Encode<crate::wire::DirEntryRouterRouteResponse, ___E>,
3114 {
3115 #[inline]
3116 fn encode_option(
3117 this: ::core::option::Option<Self>,
3118 encoder: &mut ___E,
3119 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirEntryRouterRouteResponse>,
3120 _: (),
3121 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3122 ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3123
3124 if let Some(inner) = this {
3125 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3126 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3127 } else {
3128 ::fidl_next::wire::Union::encode_absent(raw);
3129 }
3130
3131 Ok(())
3132 }
3133 }
3134
3135 impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
3136 for DirEntryRouterRouteResponse
3137 {
3138 #[inline]
3139 fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
3140 let wire = ::core::mem::ManuallyDrop::new(wire);
3141 match wire.raw.ordinal() {
3142 1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
3143 wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
3144 })),
3145
3146 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3147 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3148 })),
3149
3150 _ => unsafe { ::core::hint::unreachable_unchecked() },
3151 }
3152 }
3153 }
3154
3155 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3156 for DirEntryRouterRouteResponse
3157 {
3158 #[inline]
3159 fn from_wire_option(
3160 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3161 ) -> ::core::option::Option<Self> {
3162 if let Some(inner) = wire.into_option() {
3163 Some(::fidl_next::FromWire::from_wire(inner))
3164 } else {
3165 None
3166 }
3167 }
3168 }
3169
3170 impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
3171 for Box<DirEntryRouterRouteResponse>
3172 {
3173 #[inline]
3174 fn from_wire_option(
3175 wire: crate::wire_optional::DirEntryRouterRouteResponse,
3176 ) -> ::core::option::Option<Self> {
3177 <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
3178 crate::wire_optional::DirEntryRouterRouteResponse,
3179 >>::from_wire_option(wire)
3180 .map(Box::new)
3181 }
3182 }
3183
3184 #[derive(Debug, Default, PartialEq)]
3185 pub struct DirReceiverReceiveRequest {
3186 pub channel: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
3187
3188 pub flags: ::core::option::Option<::fidl_next_fuchsia_io::natural::Flags>,
3189
3190 pub subdir: ::core::option::Option<::std::string::String>,
3191 }
3192
3193 impl DirReceiverReceiveRequest {
3194 fn __max_ordinal(&self) -> usize {
3195 if self.subdir.is_some() {
3196 return 3;
3197 }
3198
3199 if self.flags.is_some() {
3200 return 2;
3201 }
3202
3203 if self.channel.is_some() {
3204 return 1;
3205 }
3206
3207 0
3208 }
3209 }
3210
3211 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirReceiverReceiveRequest<'static>, ___E>
3212 for DirReceiverReceiveRequest
3213 where
3214 ___E: ::fidl_next::Encoder + ?Sized,
3215 ___E: ::fidl_next::fuchsia::HandleEncoder,
3216 {
3217 #[inline]
3218 fn encode(
3219 mut self,
3220 encoder: &mut ___E,
3221 out: &mut ::core::mem::MaybeUninit<crate::wire::DirReceiverReceiveRequest<'static>>,
3222 _: (),
3223 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3224 ::fidl_next::munge!(let crate::wire::DirReceiverReceiveRequest { table } = out);
3225
3226 let max_ord = self.__max_ordinal();
3227
3228 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
3229 ::fidl_next::Wire::zero_padding(&mut out);
3230
3231 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
3232 ::fidl_next::wire::Envelope,
3233 >(encoder, max_ord);
3234
3235 for i in 1..=max_ord {
3236 match i {
3237 3 => {
3238 if let Some(value) = self.subdir.take() {
3239 ::fidl_next::wire::Envelope::encode_value::<
3240 ::fidl_next::wire::String<'static>,
3241 ___E,
3242 >(
3243 value, preallocated.encoder, &mut out, 4095
3244 )?;
3245 } else {
3246 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3247 }
3248 }
3249
3250 2 => {
3251 if let Some(value) = self.flags.take() {
3252 ::fidl_next::wire::Envelope::encode_value::<
3253 ::fidl_next_fuchsia_io::wire::Flags,
3254 ___E,
3255 >(
3256 value, preallocated.encoder, &mut out, ()
3257 )?;
3258 } else {
3259 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3260 }
3261 }
3262
3263 1 => {
3264 if let Some(value) = self.channel.take() {
3265 ::fidl_next::wire::Envelope::encode_value::<
3266 ::fidl_next::wire::fuchsia::Channel,
3267 ___E,
3268 >(
3269 value, preallocated.encoder, &mut out, ()
3270 )?;
3271 } else {
3272 ::fidl_next::wire::Envelope::encode_zero(&mut out)
3273 }
3274 }
3275
3276 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
3277 }
3278 unsafe {
3279 preallocated.write_next(out.assume_init_ref());
3280 }
3281 }
3282
3283 ::fidl_next::wire::Table::encode_len(table, max_ord);
3284
3285 Ok(())
3286 }
3287 }
3288
3289 impl<'de> ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest<'de>>
3290 for DirReceiverReceiveRequest
3291 {
3292 #[inline]
3293 fn from_wire(wire_: crate::wire::DirReceiverReceiveRequest<'de>) -> Self {
3294 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
3295
3296 let channel = wire_.table.get(1);
3297
3298 let flags = wire_.table.get(2);
3299
3300 let subdir = wire_.table.get(3);
3301
3302 Self {
3303 channel: channel.map(|envelope| {
3304 ::fidl_next::FromWire::from_wire(unsafe {
3305 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3306 })
3307 }),
3308
3309 flags: flags.map(|envelope| {
3310 ::fidl_next::FromWire::from_wire(unsafe {
3311 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
3312 })
3313 }),
3314
3315 subdir: subdir.map(|envelope| {
3316 ::fidl_next::FromWire::from_wire(unsafe {
3317 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3318 })
3319 }),
3320 }
3321 }
3322 }
3323
3324 #[derive(Debug, PartialEq)]
3325 pub enum DirectoryRouterRouteResponse {
3326 Directory(
3327 ::fidl_next::ClientEnd<
3328 ::fidl_next_fuchsia_io::Directory,
3329 ::fidl_next::fuchsia::zx::Channel,
3330 >,
3331 ),
3332
3333 Unavailable(crate::natural::Unit),
3334 }
3335
3336 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>
3337 for DirectoryRouterRouteResponse
3338 where
3339 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3340 ___E: ::fidl_next::fuchsia::HandleEncoder,
3341 {
3342 #[inline]
3343 fn encode(
3344 self,
3345 encoder: &mut ___E,
3346 out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRouterRouteResponse>,
3347 _: (),
3348 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3349 ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
3350
3351 match self {
3352 Self::Directory(value) => ::fidl_next::wire::Union::encode_as_static::<
3353 ___E,
3354 ::fidl_next::ClientEnd<
3355 ::fidl_next_fuchsia_io::Directory,
3356 ::fidl_next::wire::fuchsia::Channel,
3357 >,
3358 >(value, 1, encoder, raw, ())?,
3359
3360 Self::Unavailable(value) => ::fidl_next::wire::Union::encode_as_static::<
3361 ___E,
3362 crate::wire::Unit,
3363 >(value, 2, encoder, raw, ())?,
3364 }
3365
3366 Ok(())
3367 }
3368 }
3369
3370 unsafe impl<___E>
3371 ::fidl_next::EncodeOption<crate::wire_optional::DirectoryRouterRouteResponse, ___E>
3372 for DirectoryRouterRouteResponse
3373 where
3374 ___E: ?Sized,
3375 DirectoryRouterRouteResponse:
3376 ::fidl_next::Encode<crate::wire::DirectoryRouterRouteResponse, ___E>,
3377 {
3378 #[inline]
3379 fn encode_option(
3380 this: ::core::option::Option<Self>,
3381 encoder: &mut ___E,
3382 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DirectoryRouterRouteResponse>,
3383 _: (),
3384 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3385 ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
3386
3387 if let Some(inner) = this {
3388 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
3389 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
3390 } else {
3391 ::fidl_next::wire::Union::encode_absent(raw);
3392 }
3393
3394 Ok(())
3395 }
3396 }
3397
3398 impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
3399 for DirectoryRouterRouteResponse
3400 {
3401 #[inline]
3402 fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
3403 let wire = ::core::mem::ManuallyDrop::new(wire);
3404 match wire.raw.ordinal() {
3405 1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
3406 wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
3407 ::fidl_next_fuchsia_io::Directory,
3408 ::fidl_next::wire::fuchsia::Channel,
3409 >>()
3410 })),
3411
3412 2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
3413 wire.raw.get().read_unchecked::<crate::wire::Unit>()
3414 })),
3415
3416 _ => unsafe { ::core::hint::unreachable_unchecked() },
3417 }
3418 }
3419 }
3420
3421 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3422 for DirectoryRouterRouteResponse
3423 {
3424 #[inline]
3425 fn from_wire_option(
3426 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3427 ) -> ::core::option::Option<Self> {
3428 if let Some(inner) = wire.into_option() {
3429 Some(::fidl_next::FromWire::from_wire(inner))
3430 } else {
3431 None
3432 }
3433 }
3434 }
3435
3436 impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
3437 for Box<DirectoryRouterRouteResponse>
3438 {
3439 #[inline]
3440 fn from_wire_option(
3441 wire: crate::wire_optional::DirectoryRouterRouteResponse,
3442 ) -> ::core::option::Option<Self> {
3443 <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
3444 crate::wire_optional::DirectoryRouterRouteResponse,
3445 >>::from_wire_option(wire)
3446 .map(Box::new)
3447 }
3448 }
3449
3450 #[doc = " Contains a protocol open request.\n"]
3451 #[derive(Debug, PartialEq)]
3452 #[repr(C)]
3453 pub struct ProtocolPayload {
3454 pub channel: ::fidl_next::fuchsia::zx::Channel,
3455 }
3456
3457 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E> for ProtocolPayload
3458 where
3459 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3460 ___E: ::fidl_next::fuchsia::HandleEncoder,
3461 {
3462 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
3463 ::fidl_next::CopyOptimization::enable_if(
3464 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encode<
3465 ::fidl_next::wire::fuchsia::Channel,
3466 ___E,
3467 >>::COPY_OPTIMIZATION
3468 .is_enabled(),
3469 )
3470 };
3471
3472 #[inline]
3473 fn encode(
3474 self,
3475 encoder_: &mut ___E,
3476 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
3477 _: (),
3478 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3479 ::fidl_next::munge! {
3480 let crate::wire::ProtocolPayload {
3481 channel,
3482
3483 } = out_;
3484 }
3485
3486 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
3487
3488 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
3489
3490 Ok(())
3491 }
3492 }
3493
3494 unsafe impl<___E>
3495 ::fidl_next::EncodeOption<
3496 ::fidl_next::wire::Box<'static, crate::wire::ProtocolPayload>,
3497 ___E,
3498 > for ProtocolPayload
3499 where
3500 ___E: ::fidl_next::Encoder + ?Sized,
3501 ProtocolPayload: ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>,
3502 {
3503 #[inline]
3504 fn encode_option(
3505 this: ::core::option::Option<Self>,
3506 encoder: &mut ___E,
3507 out: &mut ::core::mem::MaybeUninit<
3508 ::fidl_next::wire::Box<'static, crate::wire::ProtocolPayload>,
3509 >,
3510 _: (),
3511 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3512 if let Some(inner) = this {
3513 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3514 ::fidl_next::wire::Box::encode_present(out);
3515 } else {
3516 ::fidl_next::wire::Box::encode_absent(out);
3517 }
3518
3519 Ok(())
3520 }
3521 }
3522
3523 impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
3524 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
3525 ::fidl_next::CopyOptimization::enable_if(
3526 true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
3527 ::fidl_next::wire::fuchsia::Channel,
3528 >>::COPY_OPTIMIZATION
3529 .is_enabled(),
3530 )
3531 };
3532
3533 #[inline]
3534 fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
3535 Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
3536 }
3537 }
3538}
3539
3540pub mod wire {
3541
3542 pub use fidl_next_common_fuchsia_component_sandbox::wire::*;
3543
3544 pub type Token = ::fidl_next::wire::fuchsia::EventPair;
3546
3547 #[derive(Debug)]
3549 #[repr(C)]
3550 pub struct DirConnector {
3551 pub token: ::fidl_next::wire::fuchsia::EventPair,
3552 }
3553
3554 static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
3555 static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
3556
3557 static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
3558
3559 impl ::fidl_next::Constrained for DirConnector {
3560 type Constraint = ();
3561
3562 fn validate(
3563 _: ::fidl_next::Slot<'_, Self>,
3564 _: Self::Constraint,
3565 ) -> Result<(), ::fidl_next::ValidationError> {
3566 Ok(())
3567 }
3568 }
3569
3570 unsafe impl ::fidl_next::Wire for DirConnector {
3571 type Narrowed<'de> = DirConnector;
3572
3573 #[inline]
3574 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3575 ::fidl_next::munge! {
3576 let Self {
3577
3578 token,
3579
3580 } = &mut *out_;
3581 }
3582
3583 ::fidl_next::Wire::zero_padding(token);
3584 }
3585 }
3586
3587 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
3588 where
3589 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3590 ___D: ::fidl_next::fuchsia::HandleDecoder,
3591 {
3592 fn decode(
3593 slot_: ::fidl_next::Slot<'_, Self>,
3594 decoder_: &mut ___D,
3595 _: (),
3596 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3597 ::fidl_next::munge! {
3598 let Self {
3599
3600 mut token,
3601
3602 } = slot_;
3603 }
3604
3605 let _field = token.as_mut();
3606
3607 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3608
3609 Ok(())
3610 }
3611 }
3612
3613 impl ::fidl_next::IntoNatural for DirConnector {
3614 type Natural = crate::natural::DirConnector;
3615 }
3616
3617 #[repr(C)]
3619 pub struct AggregateSource<'de> {
3620 pub(crate) table: ::fidl_next::wire::Table<'de>,
3621 }
3622
3623 impl<'de> Drop for AggregateSource<'de> {
3624 fn drop(&mut self) {
3625 let _ = self
3626 .table
3627 .get(1)
3628 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DirConnector>() });
3629
3630 let _ = self.table.get(2)
3631 .map(|envelope| unsafe {
3632 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
3633 });
3634
3635 let _ = self.table.get(3).map(|envelope| unsafe {
3636 envelope.read_unchecked::<::fidl_next::wire::Vector<
3637 'de,
3638 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3639 >>()
3640 });
3641 }
3642 }
3643
3644 impl ::fidl_next::Constrained for AggregateSource<'_> {
3645 type Constraint = ();
3646
3647 fn validate(
3648 _: ::fidl_next::Slot<'_, Self>,
3649 _: Self::Constraint,
3650 ) -> Result<(), ::fidl_next::ValidationError> {
3651 Ok(())
3652 }
3653 }
3654
3655 unsafe impl ::fidl_next::Wire for AggregateSource<'static> {
3656 type Narrowed<'de> = AggregateSource<'de>;
3657
3658 #[inline]
3659 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3660 ::fidl_next::munge!(let Self { table } = out);
3661 ::fidl_next::wire::Table::zero_padding(table);
3662 }
3663 }
3664
3665 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AggregateSource<'de>
3666 where
3667 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3668 ___D: ::fidl_next::fuchsia::HandleDecoder,
3669 {
3670 fn decode(
3671 slot: ::fidl_next::Slot<'_, Self>,
3672 decoder: &mut ___D,
3673 _: (),
3674 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3675 ::fidl_next::munge!(let Self { table } = slot);
3676
3677 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3678 match ordinal {
3679 0 => unsafe { ::core::hint::unreachable_unchecked() },
3680
3681 1 => {
3682 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DirConnector>(
3683 slot.as_mut(),
3684 decoder,
3685 (),
3686 )?;
3687
3688 Ok(())
3689 }
3690
3691 2 => {
3692 ::fidl_next::wire::Envelope::decode_as::<
3693 ___D,
3694 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
3695 >(slot.as_mut(), decoder, (4294967295, 255))?;
3696
3697 Ok(())
3698 }
3699
3700 3 => {
3701 ::fidl_next::wire::Envelope::decode_as::<
3702 ___D,
3703 ::fidl_next::wire::Vector<
3704 'de,
3705 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3706 >,
3707 >(slot.as_mut(), decoder, (4294967295, ()))?;
3708
3709 Ok(())
3710 }
3711
3712 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3713 }
3714 })
3715 }
3716 }
3717
3718 impl<'de> AggregateSource<'de> {
3719 pub fn dir_connector(&self) -> ::core::option::Option<&crate::wire::DirConnector> {
3720 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3721 }
3722
3723 pub fn source_instance_filter(
3724 &self,
3725 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>
3726 {
3727 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3728 }
3729
3730 pub fn renamed_instances(
3731 &self,
3732 ) -> ::core::option::Option<
3733 &::fidl_next::wire::Vector<
3734 'de,
3735 ::fidl_next_fuchsia_component_decl::wire::NameMapping<'de>,
3736 >,
3737 > {
3738 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3739 }
3740 }
3741
3742 impl<'de> ::core::fmt::Debug for AggregateSource<'de> {
3743 fn fmt(
3744 &self,
3745 f: &mut ::core::fmt::Formatter<'_>,
3746 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3747 f.debug_struct("AggregateSource")
3748 .field("dir_connector", &self.dir_connector())
3749 .field("source_instance_filter", &self.source_instance_filter())
3750 .field("renamed_instances", &self.renamed_instances())
3751 .finish()
3752 }
3753 }
3754
3755 impl<'de> ::fidl_next::IntoNatural for AggregateSource<'de> {
3756 type Natural = crate::natural::AggregateSource;
3757 }
3758
3759 #[derive(Debug)]
3761 #[repr(C)]
3762 pub struct DictionaryRef {
3763 pub token: ::fidl_next::wire::fuchsia::EventPair,
3764 }
3765
3766 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
3767 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
3768
3769 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
3770
3771 impl ::fidl_next::Constrained for DictionaryRef {
3772 type Constraint = ();
3773
3774 fn validate(
3775 _: ::fidl_next::Slot<'_, Self>,
3776 _: Self::Constraint,
3777 ) -> Result<(), ::fidl_next::ValidationError> {
3778 Ok(())
3779 }
3780 }
3781
3782 unsafe impl ::fidl_next::Wire for DictionaryRef {
3783 type Narrowed<'de> = DictionaryRef;
3784
3785 #[inline]
3786 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3787 ::fidl_next::munge! {
3788 let Self {
3789
3790 token,
3791
3792 } = &mut *out_;
3793 }
3794
3795 ::fidl_next::Wire::zero_padding(token);
3796 }
3797 }
3798
3799 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
3800 where
3801 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3802 ___D: ::fidl_next::fuchsia::HandleDecoder,
3803 {
3804 fn decode(
3805 slot_: ::fidl_next::Slot<'_, Self>,
3806 decoder_: &mut ___D,
3807 _: (),
3808 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3809 ::fidl_next::munge! {
3810 let Self {
3811
3812 mut token,
3813
3814 } = slot_;
3815 }
3816
3817 let _field = token.as_mut();
3818
3819 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3820
3821 Ok(())
3822 }
3823 }
3824
3825 impl ::fidl_next::IntoNatural for DictionaryRef {
3826 type Natural = crate::natural::DictionaryRef;
3827 }
3828
3829 #[derive(Debug)]
3831 #[repr(C)]
3832 pub struct Connector {
3833 pub token: ::fidl_next::wire::fuchsia::EventPair,
3834 }
3835
3836 static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
3837 static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
3838
3839 static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
3840
3841 impl ::fidl_next::Constrained for Connector {
3842 type Constraint = ();
3843
3844 fn validate(
3845 _: ::fidl_next::Slot<'_, Self>,
3846 _: Self::Constraint,
3847 ) -> Result<(), ::fidl_next::ValidationError> {
3848 Ok(())
3849 }
3850 }
3851
3852 unsafe impl ::fidl_next::Wire for Connector {
3853 type Narrowed<'de> = Connector;
3854
3855 #[inline]
3856 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3857 ::fidl_next::munge! {
3858 let Self {
3859
3860 token,
3861
3862 } = &mut *out_;
3863 }
3864
3865 ::fidl_next::Wire::zero_padding(token);
3866 }
3867 }
3868
3869 unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
3870 where
3871 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3872 ___D: ::fidl_next::fuchsia::HandleDecoder,
3873 {
3874 fn decode(
3875 slot_: ::fidl_next::Slot<'_, Self>,
3876 decoder_: &mut ___D,
3877 _: (),
3878 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3879 ::fidl_next::munge! {
3880 let Self {
3881
3882 mut token,
3883
3884 } = slot_;
3885 }
3886
3887 let _field = token.as_mut();
3888
3889 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3890
3891 Ok(())
3892 }
3893 }
3894
3895 impl ::fidl_next::IntoNatural for Connector {
3896 type Natural = crate::natural::Connector;
3897 }
3898
3899 #[derive(Debug)]
3901 #[repr(C)]
3902 pub struct DirEntry {
3903 pub token: ::fidl_next::wire::fuchsia::EventPair,
3904 }
3905
3906 static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
3907 static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
3908
3909 static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
3910
3911 impl ::fidl_next::Constrained for DirEntry {
3912 type Constraint = ();
3913
3914 fn validate(
3915 _: ::fidl_next::Slot<'_, Self>,
3916 _: Self::Constraint,
3917 ) -> Result<(), ::fidl_next::ValidationError> {
3918 Ok(())
3919 }
3920 }
3921
3922 unsafe impl ::fidl_next::Wire for DirEntry {
3923 type Narrowed<'de> = DirEntry;
3924
3925 #[inline]
3926 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3927 ::fidl_next::munge! {
3928 let Self {
3929
3930 token,
3931
3932 } = &mut *out_;
3933 }
3934
3935 ::fidl_next::Wire::zero_padding(token);
3936 }
3937 }
3938
3939 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
3940 where
3941 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3942 ___D: ::fidl_next::fuchsia::HandleDecoder,
3943 {
3944 fn decode(
3945 slot_: ::fidl_next::Slot<'_, Self>,
3946 decoder_: &mut ___D,
3947 _: (),
3948 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3949 ::fidl_next::munge! {
3950 let Self {
3951
3952 mut token,
3953
3954 } = slot_;
3955 }
3956
3957 let _field = token.as_mut();
3958
3959 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3960
3961 Ok(())
3962 }
3963 }
3964
3965 impl ::fidl_next::IntoNatural for DirEntry {
3966 type Natural = crate::natural::DirEntry;
3967 }
3968
3969 #[repr(transparent)]
3971 pub struct Capability<'de> {
3972 pub(crate) raw: ::fidl_next::wire::Union,
3973 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3974 }
3975
3976 impl<'de> Drop for Capability<'de> {
3977 fn drop(&mut self) {
3978 match self.raw.ordinal() {
3979 1 => {
3980 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
3981 }
3982
3983 2 => {
3984 let _ = unsafe {
3985 self.raw
3986 .get()
3987 .read_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
3988 };
3989 }
3990
3991 3 => {
3992 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
3993 }
3994
3995 4 => {
3996 let _ =
3997 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
3998 }
3999
4000 5 => {
4001 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
4002 }
4003
4004 6 => {
4005 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
4006 }
4007
4008 7 => {
4009 let _ = unsafe {
4010 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4011 ::fidl_next_fuchsia_io::Directory,
4012 ::fidl_next::wire::fuchsia::Channel,
4013 >>()
4014 };
4015 }
4016
4017 8 => {
4018 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
4019 }
4020
4021 9 => {
4022 let _ = unsafe {
4023 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4024 crate::ConnectorRouter,
4025 ::fidl_next::wire::fuchsia::Channel,
4026 >>()
4027 };
4028 }
4029
4030 10 => {
4031 let _ = unsafe {
4032 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4033 crate::DictionaryRouter,
4034 ::fidl_next::wire::fuchsia::Channel,
4035 >>()
4036 };
4037 }
4038
4039 11 => {
4040 let _ = unsafe {
4041 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4042 crate::DirEntryRouter,
4043 ::fidl_next::wire::fuchsia::Channel,
4044 >>()
4045 };
4046 }
4047
4048 12 => {
4049 let _ = unsafe {
4050 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4051 crate::DataRouter,
4052 ::fidl_next::wire::fuchsia::Channel,
4053 >>()
4054 };
4055 }
4056
4057 13 => {
4058 let _ = unsafe {
4059 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
4060 crate::DirConnectorRouter,
4061 ::fidl_next::wire::fuchsia::Channel,
4062 >>()
4063 };
4064 }
4065
4066 _ => (),
4067 }
4068 }
4069 }
4070
4071 impl ::fidl_next::Constrained for Capability<'_> {
4072 type Constraint = ();
4073
4074 fn validate(
4075 _: ::fidl_next::Slot<'_, Self>,
4076 _: Self::Constraint,
4077 ) -> Result<(), ::fidl_next::ValidationError> {
4078 Ok(())
4079 }
4080 }
4081
4082 unsafe impl ::fidl_next::Wire for Capability<'static> {
4083 type Narrowed<'de> = Capability<'de>;
4084
4085 #[inline]
4086 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4087 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4088 ::fidl_next::wire::Union::zero_padding(raw);
4089 }
4090 }
4091
4092 pub mod capability {
4093 pub enum Ref<'de> {
4094 Unit(&'de crate::wire::Unit),
4095
4096 Handle(&'de ::fidl_next::wire::fuchsia::NullableHandle),
4097
4098 Data(&'de crate::wire::Data<'de>),
4099
4100 Dictionary(&'de crate::wire::DictionaryRef),
4101
4102 Connector(&'de crate::wire::Connector),
4103
4104 DirConnector(&'de crate::wire::DirConnector),
4105
4106 Directory(
4107 &'de ::fidl_next::ClientEnd<
4108 ::fidl_next_fuchsia_io::Directory,
4109 ::fidl_next::wire::fuchsia::Channel,
4110 >,
4111 ),
4112
4113 DirEntry(&'de crate::wire::DirEntry),
4114
4115 ConnectorRouter(
4116 &'de ::fidl_next::ClientEnd<
4117 crate::ConnectorRouter,
4118 ::fidl_next::wire::fuchsia::Channel,
4119 >,
4120 ),
4121
4122 DictionaryRouter(
4123 &'de ::fidl_next::ClientEnd<
4124 crate::DictionaryRouter,
4125 ::fidl_next::wire::fuchsia::Channel,
4126 >,
4127 ),
4128
4129 DirEntryRouter(
4130 &'de ::fidl_next::ClientEnd<
4131 crate::DirEntryRouter,
4132 ::fidl_next::wire::fuchsia::Channel,
4133 >,
4134 ),
4135
4136 DataRouter(
4137 &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
4138 ),
4139
4140 DirConnectorRouter(
4141 &'de ::fidl_next::ClientEnd<
4142 crate::DirConnectorRouter,
4143 ::fidl_next::wire::fuchsia::Channel,
4144 >,
4145 ),
4146
4147 UnknownOrdinal_(u64),
4148 }
4149 }
4150
4151 impl<'de> Capability<'de> {
4152 pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
4153 match self.raw.ordinal() {
4154 1 => crate::wire::capability::Ref::Unit(unsafe {
4155 self.raw.get().deref_unchecked::<crate::wire::Unit>()
4156 }),
4157
4158 2 => crate::wire::capability::Ref::Handle(unsafe {
4159 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
4160 }),
4161
4162 3 => crate::wire::capability::Ref::Data(unsafe {
4163 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
4164 }),
4165
4166 4 => crate::wire::capability::Ref::Dictionary(unsafe {
4167 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
4168 }),
4169
4170 5 => crate::wire::capability::Ref::Connector(unsafe {
4171 self.raw.get().deref_unchecked::<crate::wire::Connector>()
4172 }),
4173
4174 6 => crate::wire::capability::Ref::DirConnector(unsafe {
4175 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
4176 }),
4177
4178 7 => crate::wire::capability::Ref::Directory(unsafe {
4179 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4180 ::fidl_next_fuchsia_io::Directory,
4181 ::fidl_next::wire::fuchsia::Channel,
4182 >>()
4183 }),
4184
4185 8 => crate::wire::capability::Ref::DirEntry(unsafe {
4186 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
4187 }),
4188
4189 9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
4190 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4191 crate::ConnectorRouter,
4192 ::fidl_next::wire::fuchsia::Channel,
4193 >>()
4194 }),
4195
4196 10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
4197 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4198 crate::DictionaryRouter,
4199 ::fidl_next::wire::fuchsia::Channel,
4200 >>()
4201 }),
4202
4203 11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
4204 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4205 crate::DirEntryRouter,
4206 ::fidl_next::wire::fuchsia::Channel,
4207 >>()
4208 }),
4209
4210 12 => crate::wire::capability::Ref::DataRouter(unsafe {
4211 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4212 crate::DataRouter,
4213 ::fidl_next::wire::fuchsia::Channel,
4214 >>()
4215 }),
4216
4217 13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
4218 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
4219 crate::DirConnectorRouter,
4220 ::fidl_next::wire::fuchsia::Channel,
4221 >>()
4222 }),
4223
4224 unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
4225 }
4226 }
4227 }
4228
4229 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
4230 where
4231 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4232 ___D: ::fidl_next::Decoder<'de>,
4233 ___D: ::fidl_next::fuchsia::HandleDecoder,
4234 {
4235 fn decode(
4236 mut slot: ::fidl_next::Slot<'_, Self>,
4237 decoder: &mut ___D,
4238 _: (),
4239 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4240 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4241 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4242 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
4243 raw,
4244 decoder,
4245 (),
4246 )?,
4247
4248 2 => ::fidl_next::wire::Union::decode_as::<
4249 ___D,
4250 ::fidl_next::wire::fuchsia::NullableHandle,
4251 >(raw, decoder, ())?,
4252
4253 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
4254 raw,
4255 decoder,
4256 (),
4257 )?,
4258
4259 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DictionaryRef>(
4260 raw,
4261 decoder,
4262 (),
4263 )?,
4264
4265 5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Connector>(
4266 raw,
4267 decoder,
4268 (),
4269 )?,
4270
4271 6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirConnector>(
4272 raw,
4273 decoder,
4274 (),
4275 )?,
4276
4277 7 => ::fidl_next::wire::Union::decode_as::<
4278 ___D,
4279 ::fidl_next::ClientEnd<
4280 ::fidl_next_fuchsia_io::Directory,
4281 ::fidl_next::wire::fuchsia::Channel,
4282 >,
4283 >(raw, decoder, ())?,
4284
4285 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirEntry>(
4286 raw,
4287 decoder,
4288 (),
4289 )?,
4290
4291 9 => ::fidl_next::wire::Union::decode_as::<
4292 ___D,
4293 ::fidl_next::ClientEnd<
4294 crate::ConnectorRouter,
4295 ::fidl_next::wire::fuchsia::Channel,
4296 >,
4297 >(raw, decoder, ())?,
4298
4299 10 => ::fidl_next::wire::Union::decode_as::<
4300 ___D,
4301 ::fidl_next::ClientEnd<
4302 crate::DictionaryRouter,
4303 ::fidl_next::wire::fuchsia::Channel,
4304 >,
4305 >(raw, decoder, ())?,
4306
4307 11 => ::fidl_next::wire::Union::decode_as::<
4308 ___D,
4309 ::fidl_next::ClientEnd<
4310 crate::DirEntryRouter,
4311 ::fidl_next::wire::fuchsia::Channel,
4312 >,
4313 >(raw, decoder, ())?,
4314
4315 12 => ::fidl_next::wire::Union::decode_as::<
4316 ___D,
4317 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
4318 >(raw, decoder, ())?,
4319
4320 13 => ::fidl_next::wire::Union::decode_as::<
4321 ___D,
4322 ::fidl_next::ClientEnd<
4323 crate::DirConnectorRouter,
4324 ::fidl_next::wire::fuchsia::Channel,
4325 >,
4326 >(raw, decoder, ())?,
4327
4328 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4329 }
4330
4331 Ok(())
4332 }
4333 }
4334
4335 impl<'de> ::core::fmt::Debug for Capability<'de> {
4336 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4337 match self.raw.ordinal() {
4338 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
4339 2 => unsafe {
4340 self.raw
4341 .get()
4342 .deref_unchecked::<::fidl_next::wire::fuchsia::NullableHandle>()
4343 .fmt(f)
4344 },
4345 3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
4346 4 => unsafe {
4347 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
4348 },
4349 5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
4350 6 => unsafe {
4351 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
4352 },
4353 7 => unsafe {
4354 self.raw
4355 .get()
4356 .deref_unchecked::<::fidl_next::ClientEnd<
4357 ::fidl_next_fuchsia_io::Directory,
4358 ::fidl_next::wire::fuchsia::Channel,
4359 >>()
4360 .fmt(f)
4361 },
4362 8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
4363 9 => unsafe {
4364 self.raw
4365 .get()
4366 .deref_unchecked::<::fidl_next::ClientEnd<
4367 crate::ConnectorRouter,
4368 ::fidl_next::wire::fuchsia::Channel,
4369 >>()
4370 .fmt(f)
4371 },
4372 10 => unsafe {
4373 self.raw
4374 .get()
4375 .deref_unchecked::<::fidl_next::ClientEnd<
4376 crate::DictionaryRouter,
4377 ::fidl_next::wire::fuchsia::Channel,
4378 >>()
4379 .fmt(f)
4380 },
4381 11 => unsafe {
4382 self.raw
4383 .get()
4384 .deref_unchecked::<::fidl_next::ClientEnd<
4385 crate::DirEntryRouter,
4386 ::fidl_next::wire::fuchsia::Channel,
4387 >>()
4388 .fmt(f)
4389 },
4390 12 => unsafe {
4391 self.raw
4392 .get()
4393 .deref_unchecked::<::fidl_next::ClientEnd<
4394 crate::DataRouter,
4395 ::fidl_next::wire::fuchsia::Channel,
4396 >>()
4397 .fmt(f)
4398 },
4399 13 => unsafe {
4400 self.raw
4401 .get()
4402 .deref_unchecked::<::fidl_next::ClientEnd<
4403 crate::DirConnectorRouter,
4404 ::fidl_next::wire::fuchsia::Channel,
4405 >>()
4406 .fmt(f)
4407 },
4408 _ => unsafe { ::core::hint::unreachable_unchecked() },
4409 }
4410 }
4411 }
4412
4413 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
4414 type Natural = crate::natural::Capability;
4415 }
4416
4417 #[derive(Debug)]
4419 #[repr(C)]
4420 pub struct CapabilityStoreConnectorCreateRequest {
4421 pub id: ::fidl_next::wire::Uint64,
4422
4423 pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
4424 }
4425
4426 static_assertions::const_assert_eq!(
4427 std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
4428 16
4429 );
4430 static_assertions::const_assert_eq!(
4431 std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
4432 8
4433 );
4434
4435 static_assertions::const_assert_eq!(
4436 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
4437 0
4438 );
4439
4440 static_assertions::const_assert_eq!(
4441 std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
4442 8
4443 );
4444
4445 impl ::fidl_next::Constrained for CapabilityStoreConnectorCreateRequest {
4446 type Constraint = ();
4447
4448 fn validate(
4449 _: ::fidl_next::Slot<'_, Self>,
4450 _: Self::Constraint,
4451 ) -> Result<(), ::fidl_next::ValidationError> {
4452 Ok(())
4453 }
4454 }
4455
4456 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
4457 type Narrowed<'de> = CapabilityStoreConnectorCreateRequest;
4458
4459 #[inline]
4460 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4461 ::fidl_next::munge! {
4462 let Self {
4463
4464 id,
4465 receiver,
4466
4467 } = &mut *out_;
4468 }
4469
4470 ::fidl_next::Wire::zero_padding(id);
4471
4472 ::fidl_next::Wire::zero_padding(receiver);
4473
4474 unsafe {
4475 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4476 }
4477 }
4478 }
4479
4480 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
4481 where
4482 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4483 ___D: ::fidl_next::fuchsia::HandleDecoder,
4484 {
4485 fn decode(
4486 slot_: ::fidl_next::Slot<'_, Self>,
4487 decoder_: &mut ___D,
4488 _: (),
4489 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4490 if slot_.as_bytes()[12..16] != [0u8; 4] {
4491 return Err(::fidl_next::DecodeError::InvalidPadding);
4492 }
4493
4494 ::fidl_next::munge! {
4495 let Self {
4496
4497 mut id,
4498 mut receiver,
4499
4500 } = slot_;
4501 }
4502
4503 let _field = id.as_mut();
4504
4505 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4506
4507 let _field = receiver.as_mut();
4508
4509 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4510
4511 Ok(())
4512 }
4513 }
4514
4515 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
4516 type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
4517 }
4518
4519 #[derive(Debug)]
4521 #[repr(C)]
4522 pub struct CapabilityStoreConnectorOpenRequest {
4523 pub id: ::fidl_next::wire::Uint64,
4524
4525 pub server_end: ::fidl_next::wire::fuchsia::Channel,
4526 }
4527
4528 static_assertions::const_assert_eq!(
4529 std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
4530 16
4531 );
4532 static_assertions::const_assert_eq!(
4533 std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
4534 8
4535 );
4536
4537 static_assertions::const_assert_eq!(
4538 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
4539 0
4540 );
4541
4542 static_assertions::const_assert_eq!(
4543 std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
4544 8
4545 );
4546
4547 impl ::fidl_next::Constrained for CapabilityStoreConnectorOpenRequest {
4548 type Constraint = ();
4549
4550 fn validate(
4551 _: ::fidl_next::Slot<'_, Self>,
4552 _: Self::Constraint,
4553 ) -> Result<(), ::fidl_next::ValidationError> {
4554 Ok(())
4555 }
4556 }
4557
4558 unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
4559 type Narrowed<'de> = CapabilityStoreConnectorOpenRequest;
4560
4561 #[inline]
4562 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4563 ::fidl_next::munge! {
4564 let Self {
4565
4566 id,
4567 server_end,
4568
4569 } = &mut *out_;
4570 }
4571
4572 ::fidl_next::Wire::zero_padding(id);
4573
4574 ::fidl_next::Wire::zero_padding(server_end);
4575
4576 unsafe {
4577 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4578 }
4579 }
4580 }
4581
4582 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
4583 where
4584 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4585 ___D: ::fidl_next::fuchsia::HandleDecoder,
4586 {
4587 fn decode(
4588 slot_: ::fidl_next::Slot<'_, Self>,
4589 decoder_: &mut ___D,
4590 _: (),
4591 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4592 if slot_.as_bytes()[12..16] != [0u8; 4] {
4593 return Err(::fidl_next::DecodeError::InvalidPadding);
4594 }
4595
4596 ::fidl_next::munge! {
4597 let Self {
4598
4599 mut id,
4600 mut server_end,
4601
4602 } = slot_;
4603 }
4604
4605 let _field = id.as_mut();
4606
4607 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4608
4609 let _field = server_end.as_mut();
4610
4611 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4612
4613 Ok(())
4614 }
4615 }
4616
4617 impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
4618 type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
4619 }
4620
4621 #[derive(Debug)]
4623 #[repr(C)]
4624 pub struct CapabilityStoreDirConnectorCreateRequest {
4625 pub id: ::fidl_next::wire::Uint64,
4626
4627 pub receiver:
4628 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
4629 }
4630
4631 static_assertions::const_assert_eq!(
4632 std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
4633 16
4634 );
4635 static_assertions::const_assert_eq!(
4636 std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
4637 8
4638 );
4639
4640 static_assertions::const_assert_eq!(
4641 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
4642 0
4643 );
4644
4645 static_assertions::const_assert_eq!(
4646 std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
4647 8
4648 );
4649
4650 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorCreateRequest {
4651 type Constraint = ();
4652
4653 fn validate(
4654 _: ::fidl_next::Slot<'_, Self>,
4655 _: Self::Constraint,
4656 ) -> Result<(), ::fidl_next::ValidationError> {
4657 Ok(())
4658 }
4659 }
4660
4661 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
4662 type Narrowed<'de> = CapabilityStoreDirConnectorCreateRequest;
4663
4664 #[inline]
4665 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4666 ::fidl_next::munge! {
4667 let Self {
4668
4669 id,
4670 receiver,
4671
4672 } = &mut *out_;
4673 }
4674
4675 ::fidl_next::Wire::zero_padding(id);
4676
4677 ::fidl_next::Wire::zero_padding(receiver);
4678
4679 unsafe {
4680 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4681 }
4682 }
4683 }
4684
4685 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
4686 where
4687 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4688 ___D: ::fidl_next::fuchsia::HandleDecoder,
4689 {
4690 fn decode(
4691 slot_: ::fidl_next::Slot<'_, Self>,
4692 decoder_: &mut ___D,
4693 _: (),
4694 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4695 if slot_.as_bytes()[12..16] != [0u8; 4] {
4696 return Err(::fidl_next::DecodeError::InvalidPadding);
4697 }
4698
4699 ::fidl_next::munge! {
4700 let Self {
4701
4702 mut id,
4703 mut receiver,
4704
4705 } = slot_;
4706 }
4707
4708 let _field = id.as_mut();
4709
4710 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4711
4712 let _field = receiver.as_mut();
4713
4714 ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
4715
4716 Ok(())
4717 }
4718 }
4719
4720 impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
4721 type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
4722 }
4723
4724 #[derive(Debug)]
4726 #[repr(C)]
4727 pub struct CapabilityStoreDictionaryLegacyImportRequest {
4728 pub id: ::fidl_next::wire::Uint64,
4729
4730 pub client_end: ::fidl_next::wire::fuchsia::Channel,
4731 }
4732
4733 static_assertions::const_assert_eq!(
4734 std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4735 16
4736 );
4737 static_assertions::const_assert_eq!(
4738 std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
4739 8
4740 );
4741
4742 static_assertions::const_assert_eq!(
4743 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
4744 0
4745 );
4746
4747 static_assertions::const_assert_eq!(
4748 std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
4749 8
4750 );
4751
4752 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyImportRequest {
4753 type Constraint = ();
4754
4755 fn validate(
4756 _: ::fidl_next::Slot<'_, Self>,
4757 _: Self::Constraint,
4758 ) -> Result<(), ::fidl_next::ValidationError> {
4759 Ok(())
4760 }
4761 }
4762
4763 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
4764 type Narrowed<'de> = CapabilityStoreDictionaryLegacyImportRequest;
4765
4766 #[inline]
4767 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4768 ::fidl_next::munge! {
4769 let Self {
4770
4771 id,
4772 client_end,
4773
4774 } = &mut *out_;
4775 }
4776
4777 ::fidl_next::Wire::zero_padding(id);
4778
4779 ::fidl_next::Wire::zero_padding(client_end);
4780
4781 unsafe {
4782 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4783 }
4784 }
4785 }
4786
4787 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
4788 where
4789 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4790 ___D: ::fidl_next::fuchsia::HandleDecoder,
4791 {
4792 fn decode(
4793 slot_: ::fidl_next::Slot<'_, Self>,
4794 decoder_: &mut ___D,
4795 _: (),
4796 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4797 if slot_.as_bytes()[12..16] != [0u8; 4] {
4798 return Err(::fidl_next::DecodeError::InvalidPadding);
4799 }
4800
4801 ::fidl_next::munge! {
4802 let Self {
4803
4804 mut id,
4805 mut client_end,
4806
4807 } = slot_;
4808 }
4809
4810 let _field = id.as_mut();
4811
4812 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4813
4814 let _field = client_end.as_mut();
4815
4816 ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
4817
4818 Ok(())
4819 }
4820 }
4821
4822 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
4823 type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
4824 }
4825
4826 #[derive(Debug)]
4828 #[repr(C)]
4829 pub struct CapabilityStoreDictionaryLegacyExportRequest {
4830 pub id: ::fidl_next::wire::Uint64,
4831
4832 pub server_end: ::fidl_next::wire::fuchsia::Channel,
4833 }
4834
4835 static_assertions::const_assert_eq!(
4836 std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4837 16
4838 );
4839 static_assertions::const_assert_eq!(
4840 std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
4841 8
4842 );
4843
4844 static_assertions::const_assert_eq!(
4845 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
4846 0
4847 );
4848
4849 static_assertions::const_assert_eq!(
4850 std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
4851 8
4852 );
4853
4854 impl ::fidl_next::Constrained for CapabilityStoreDictionaryLegacyExportRequest {
4855 type Constraint = ();
4856
4857 fn validate(
4858 _: ::fidl_next::Slot<'_, Self>,
4859 _: Self::Constraint,
4860 ) -> Result<(), ::fidl_next::ValidationError> {
4861 Ok(())
4862 }
4863 }
4864
4865 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
4866 type Narrowed<'de> = CapabilityStoreDictionaryLegacyExportRequest;
4867
4868 #[inline]
4869 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4870 ::fidl_next::munge! {
4871 let Self {
4872
4873 id,
4874 server_end,
4875
4876 } = &mut *out_;
4877 }
4878
4879 ::fidl_next::Wire::zero_padding(id);
4880
4881 ::fidl_next::Wire::zero_padding(server_end);
4882
4883 unsafe {
4884 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4885 }
4886 }
4887 }
4888
4889 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
4890 where
4891 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4892 ___D: ::fidl_next::fuchsia::HandleDecoder,
4893 {
4894 fn decode(
4895 slot_: ::fidl_next::Slot<'_, Self>,
4896 decoder_: &mut ___D,
4897 _: (),
4898 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4899 if slot_.as_bytes()[12..16] != [0u8; 4] {
4900 return Err(::fidl_next::DecodeError::InvalidPadding);
4901 }
4902
4903 ::fidl_next::munge! {
4904 let Self {
4905
4906 mut id,
4907 mut server_end,
4908
4909 } = slot_;
4910 }
4911
4912 let _field = id.as_mut();
4913
4914 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4915
4916 let _field = server_end.as_mut();
4917
4918 ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
4919
4920 Ok(())
4921 }
4922 }
4923
4924 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
4925 type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
4926 }
4927
4928 #[derive(Debug)]
4930 #[repr(C)]
4931 pub struct CapabilityStoreDictionaryKeysRequest {
4932 pub id: ::fidl_next::wire::Uint64,
4933
4934 pub iterator: ::fidl_next::ServerEnd<
4935 crate::DictionaryKeysIterator,
4936 ::fidl_next::wire::fuchsia::Channel,
4937 >,
4938 }
4939
4940 static_assertions::const_assert_eq!(
4941 std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
4942 16
4943 );
4944 static_assertions::const_assert_eq!(
4945 std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
4946 8
4947 );
4948
4949 static_assertions::const_assert_eq!(
4950 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
4951 0
4952 );
4953
4954 static_assertions::const_assert_eq!(
4955 std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
4956 8
4957 );
4958
4959 impl ::fidl_next::Constrained for CapabilityStoreDictionaryKeysRequest {
4960 type Constraint = ();
4961
4962 fn validate(
4963 _: ::fidl_next::Slot<'_, Self>,
4964 _: Self::Constraint,
4965 ) -> Result<(), ::fidl_next::ValidationError> {
4966 Ok(())
4967 }
4968 }
4969
4970 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
4971 type Narrowed<'de> = CapabilityStoreDictionaryKeysRequest;
4972
4973 #[inline]
4974 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4975 ::fidl_next::munge! {
4976 let Self {
4977
4978 id,
4979 iterator,
4980
4981 } = &mut *out_;
4982 }
4983
4984 ::fidl_next::Wire::zero_padding(id);
4985
4986 ::fidl_next::Wire::zero_padding(iterator);
4987
4988 unsafe {
4989 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4990 }
4991 }
4992 }
4993
4994 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
4995 where
4996 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4997 ___D: ::fidl_next::fuchsia::HandleDecoder,
4998 {
4999 fn decode(
5000 slot_: ::fidl_next::Slot<'_, Self>,
5001 decoder_: &mut ___D,
5002 _: (),
5003 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5004 if slot_.as_bytes()[12..16] != [0u8; 4] {
5005 return Err(::fidl_next::DecodeError::InvalidPadding);
5006 }
5007
5008 ::fidl_next::munge! {
5009 let Self {
5010
5011 mut id,
5012 mut iterator,
5013
5014 } = slot_;
5015 }
5016
5017 let _field = id.as_mut();
5018
5019 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5020
5021 let _field = iterator.as_mut();
5022
5023 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5024
5025 Ok(())
5026 }
5027 }
5028
5029 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
5030 type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
5031 }
5032
5033 #[derive(Debug)]
5035 #[repr(C)]
5036 pub struct CapabilityStoreDictionaryEnumerateRequest {
5037 pub id: ::fidl_next::wire::Uint64,
5038
5039 pub iterator: ::fidl_next::ServerEnd<
5040 crate::DictionaryEnumerateIterator,
5041 ::fidl_next::wire::fuchsia::Channel,
5042 >,
5043 }
5044
5045 static_assertions::const_assert_eq!(
5046 std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
5047 16
5048 );
5049 static_assertions::const_assert_eq!(
5050 std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
5051 8
5052 );
5053
5054 static_assertions::const_assert_eq!(
5055 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
5056 0
5057 );
5058
5059 static_assertions::const_assert_eq!(
5060 std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
5061 8
5062 );
5063
5064 impl ::fidl_next::Constrained for CapabilityStoreDictionaryEnumerateRequest {
5065 type Constraint = ();
5066
5067 fn validate(
5068 _: ::fidl_next::Slot<'_, Self>,
5069 _: Self::Constraint,
5070 ) -> Result<(), ::fidl_next::ValidationError> {
5071 Ok(())
5072 }
5073 }
5074
5075 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
5076 type Narrowed<'de> = CapabilityStoreDictionaryEnumerateRequest;
5077
5078 #[inline]
5079 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5080 ::fidl_next::munge! {
5081 let Self {
5082
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 CapabilityStoreDictionaryEnumerateRequest
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
5116 mut id,
5117 mut iterator,
5118
5119 } = slot_;
5120 }
5121
5122 let _field = id.as_mut();
5123
5124 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5125
5126 let _field = iterator.as_mut();
5127
5128 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5129
5130 Ok(())
5131 }
5132 }
5133
5134 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
5135 type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
5136 }
5137
5138 #[derive(Debug)]
5140 #[repr(C)]
5141 pub struct CapabilityStoreDictionaryDrainRequest {
5142 pub id: ::fidl_next::wire::Uint64,
5143
5144 pub iterator: ::fidl_next::ServerEnd<
5145 crate::DictionaryDrainIterator,
5146 ::fidl_next::wire::fuchsia::OptionalChannel,
5147 >,
5148 }
5149
5150 static_assertions::const_assert_eq!(
5151 std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
5152 16
5153 );
5154 static_assertions::const_assert_eq!(
5155 std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
5156 8
5157 );
5158
5159 static_assertions::const_assert_eq!(
5160 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
5161 0
5162 );
5163
5164 static_assertions::const_assert_eq!(
5165 std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
5166 8
5167 );
5168
5169 impl ::fidl_next::Constrained for CapabilityStoreDictionaryDrainRequest {
5170 type Constraint = ();
5171
5172 fn validate(
5173 _: ::fidl_next::Slot<'_, Self>,
5174 _: Self::Constraint,
5175 ) -> Result<(), ::fidl_next::ValidationError> {
5176 Ok(())
5177 }
5178 }
5179
5180 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
5181 type Narrowed<'de> = CapabilityStoreDictionaryDrainRequest;
5182
5183 #[inline]
5184 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5185 ::fidl_next::munge! {
5186 let Self {
5187
5188 id,
5189 iterator,
5190
5191 } = &mut *out_;
5192 }
5193
5194 ::fidl_next::Wire::zero_padding(id);
5195
5196 ::fidl_next::Wire::zero_padding(iterator);
5197
5198 unsafe {
5199 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5200 }
5201 }
5202 }
5203
5204 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
5205 where
5206 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5207 ___D: ::fidl_next::fuchsia::HandleDecoder,
5208 {
5209 fn decode(
5210 slot_: ::fidl_next::Slot<'_, Self>,
5211 decoder_: &mut ___D,
5212 _: (),
5213 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5214 if slot_.as_bytes()[12..16] != [0u8; 4] {
5215 return Err(::fidl_next::DecodeError::InvalidPadding);
5216 }
5217
5218 ::fidl_next::munge! {
5219 let Self {
5220
5221 mut id,
5222 mut iterator,
5223
5224 } = slot_;
5225 }
5226
5227 let _field = id.as_mut();
5228
5229 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5230
5231 let _field = iterator.as_mut();
5232
5233 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
5234
5235 Ok(())
5236 }
5237 }
5238
5239 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
5240 type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
5241 }
5242
5243 #[derive(Debug)]
5245 #[repr(C)]
5246 pub struct CapabilityStoreCreateServiceAggregateRequest<'de> {
5247 pub sources: ::fidl_next::wire::Vector<'de, crate::wire::AggregateSource<'de>>,
5248 }
5249
5250 static_assertions::const_assert_eq!(
5251 std::mem::size_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5252 16
5253 );
5254 static_assertions::const_assert_eq!(
5255 std::mem::align_of::<CapabilityStoreCreateServiceAggregateRequest<'_>>(),
5256 8
5257 );
5258
5259 static_assertions::const_assert_eq!(
5260 std::mem::offset_of!(CapabilityStoreCreateServiceAggregateRequest<'_>, sources),
5261 0
5262 );
5263
5264 impl ::fidl_next::Constrained for CapabilityStoreCreateServiceAggregateRequest<'_> {
5265 type Constraint = ();
5266
5267 fn validate(
5268 _: ::fidl_next::Slot<'_, Self>,
5269 _: Self::Constraint,
5270 ) -> Result<(), ::fidl_next::ValidationError> {
5271 Ok(())
5272 }
5273 }
5274
5275 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateRequest<'static> {
5276 type Narrowed<'de> = CapabilityStoreCreateServiceAggregateRequest<'de>;
5277
5278 #[inline]
5279 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5280 ::fidl_next::munge! {
5281 let Self {
5282
5283 sources,
5284
5285 } = &mut *out_;
5286 }
5287
5288 ::fidl_next::Wire::zero_padding(sources);
5289 }
5290 }
5291
5292 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5293 for CapabilityStoreCreateServiceAggregateRequest<'de>
5294 where
5295 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5296 ___D: ::fidl_next::Decoder<'de>,
5297 ___D: ::fidl_next::fuchsia::HandleDecoder,
5298 {
5299 fn decode(
5300 slot_: ::fidl_next::Slot<'_, Self>,
5301 decoder_: &mut ___D,
5302 _: (),
5303 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5304 ::fidl_next::munge! {
5305 let Self {
5306
5307 mut sources,
5308
5309 } = slot_;
5310 }
5311
5312 let _field = sources.as_mut();
5313 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5314 ::fidl_next::Decode::decode(sources.as_mut(), decoder_, (4294967295, ()))?;
5315
5316 Ok(())
5317 }
5318 }
5319
5320 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateRequest<'de> {
5321 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateRequest;
5322 }
5323
5324 #[derive(Debug)]
5326 #[repr(C)]
5327 pub struct CapabilityStoreCreateServiceAggregateResponse {
5328 pub aggregate_dir_connector: crate::wire::DirConnector,
5329 }
5330
5331 static_assertions::const_assert_eq!(
5332 std::mem::size_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5333 4
5334 );
5335 static_assertions::const_assert_eq!(
5336 std::mem::align_of::<CapabilityStoreCreateServiceAggregateResponse>(),
5337 4
5338 );
5339
5340 static_assertions::const_assert_eq!(
5341 std::mem::offset_of!(
5342 CapabilityStoreCreateServiceAggregateResponse,
5343 aggregate_dir_connector
5344 ),
5345 0
5346 );
5347
5348 impl ::fidl_next::Constrained for CapabilityStoreCreateServiceAggregateResponse {
5349 type Constraint = ();
5350
5351 fn validate(
5352 _: ::fidl_next::Slot<'_, Self>,
5353 _: Self::Constraint,
5354 ) -> Result<(), ::fidl_next::ValidationError> {
5355 Ok(())
5356 }
5357 }
5358
5359 unsafe impl ::fidl_next::Wire for CapabilityStoreCreateServiceAggregateResponse {
5360 type Narrowed<'de> = CapabilityStoreCreateServiceAggregateResponse;
5361
5362 #[inline]
5363 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5364 ::fidl_next::munge! {
5365 let Self {
5366
5367 aggregate_dir_connector,
5368
5369 } = &mut *out_;
5370 }
5371
5372 ::fidl_next::Wire::zero_padding(aggregate_dir_connector);
5373 }
5374 }
5375
5376 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreCreateServiceAggregateResponse
5377 where
5378 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5379 ___D: ::fidl_next::fuchsia::HandleDecoder,
5380 {
5381 fn decode(
5382 slot_: ::fidl_next::Slot<'_, Self>,
5383 decoder_: &mut ___D,
5384 _: (),
5385 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5386 ::fidl_next::munge! {
5387 let Self {
5388
5389 mut aggregate_dir_connector,
5390
5391 } = slot_;
5392 }
5393
5394 let _field = aggregate_dir_connector.as_mut();
5395
5396 ::fidl_next::Decode::decode(aggregate_dir_connector.as_mut(), decoder_, ())?;
5397
5398 Ok(())
5399 }
5400 }
5401
5402 impl ::fidl_next::IntoNatural for CapabilityStoreCreateServiceAggregateResponse {
5403 type Natural = crate::natural::CapabilityStoreCreateServiceAggregateResponse;
5404 }
5405
5406 #[derive(Debug)]
5408 #[repr(C)]
5409 pub struct CapabilityStoreExportResponse<'de> {
5410 pub capability: crate::wire::Capability<'de>,
5411 }
5412
5413 static_assertions::const_assert_eq!(
5414 std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
5415 16
5416 );
5417 static_assertions::const_assert_eq!(
5418 std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
5419 8
5420 );
5421
5422 static_assertions::const_assert_eq!(
5423 std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
5424 0
5425 );
5426
5427 impl ::fidl_next::Constrained for CapabilityStoreExportResponse<'_> {
5428 type Constraint = ();
5429
5430 fn validate(
5431 _: ::fidl_next::Slot<'_, Self>,
5432 _: Self::Constraint,
5433 ) -> Result<(), ::fidl_next::ValidationError> {
5434 Ok(())
5435 }
5436 }
5437
5438 unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
5439 type Narrowed<'de> = CapabilityStoreExportResponse<'de>;
5440
5441 #[inline]
5442 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5443 ::fidl_next::munge! {
5444 let Self {
5445
5446 capability,
5447
5448 } = &mut *out_;
5449 }
5450
5451 ::fidl_next::Wire::zero_padding(capability);
5452 }
5453 }
5454
5455 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'de>
5456 where
5457 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5458 ___D: ::fidl_next::Decoder<'de>,
5459 ___D: ::fidl_next::fuchsia::HandleDecoder,
5460 {
5461 fn decode(
5462 slot_: ::fidl_next::Slot<'_, Self>,
5463 decoder_: &mut ___D,
5464 _: (),
5465 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5466 ::fidl_next::munge! {
5467 let Self {
5468
5469 mut capability,
5470
5471 } = slot_;
5472 }
5473
5474 let _field = capability.as_mut();
5475
5476 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5477
5478 Ok(())
5479 }
5480 }
5481
5482 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
5483 type Natural = crate::natural::CapabilityStoreExportResponse;
5484 }
5485
5486 #[derive(Debug)]
5488 #[repr(C)]
5489 pub struct CapabilityStoreImportRequest<'de> {
5490 pub id: ::fidl_next::wire::Uint64,
5491
5492 pub capability: crate::wire::Capability<'de>,
5493 }
5494
5495 static_assertions::const_assert_eq!(
5496 std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
5497 24
5498 );
5499 static_assertions::const_assert_eq!(
5500 std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
5501 8
5502 );
5503
5504 static_assertions::const_assert_eq!(
5505 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
5506 0
5507 );
5508
5509 static_assertions::const_assert_eq!(
5510 std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
5511 8
5512 );
5513
5514 impl ::fidl_next::Constrained for CapabilityStoreImportRequest<'_> {
5515 type Constraint = ();
5516
5517 fn validate(
5518 _: ::fidl_next::Slot<'_, Self>,
5519 _: Self::Constraint,
5520 ) -> Result<(), ::fidl_next::ValidationError> {
5521 Ok(())
5522 }
5523 }
5524
5525 unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
5526 type Narrowed<'de> = CapabilityStoreImportRequest<'de>;
5527
5528 #[inline]
5529 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5530 ::fidl_next::munge! {
5531 let Self {
5532
5533 id,
5534 capability,
5535
5536 } = &mut *out_;
5537 }
5538
5539 ::fidl_next::Wire::zero_padding(id);
5540
5541 ::fidl_next::Wire::zero_padding(capability);
5542 }
5543 }
5544
5545 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'de>
5546 where
5547 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5548 ___D: ::fidl_next::Decoder<'de>,
5549 ___D: ::fidl_next::fuchsia::HandleDecoder,
5550 {
5551 fn decode(
5552 slot_: ::fidl_next::Slot<'_, Self>,
5553 decoder_: &mut ___D,
5554 _: (),
5555 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5556 ::fidl_next::munge! {
5557 let Self {
5558
5559 mut id,
5560 mut capability,
5561
5562 } = slot_;
5563 }
5564
5565 let _field = id.as_mut();
5566
5567 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
5568
5569 let _field = capability.as_mut();
5570
5571 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5572
5573 Ok(())
5574 }
5575 }
5576
5577 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
5578 type Natural = crate::natural::CapabilityStoreImportRequest;
5579 }
5580
5581 #[repr(C)]
5583 pub struct CapabilityStoreDirConnectorOpenRequest<'de> {
5584 pub(crate) table: ::fidl_next::wire::Table<'de>,
5585 }
5586
5587 impl<'de> Drop for CapabilityStoreDirConnectorOpenRequest<'de> {
5588 fn drop(&mut self) {
5589 let _ = self
5590 .table
5591 .get(1)
5592 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
5593
5594 let _ = self.table.get(2).map(|envelope| unsafe {
5595 envelope.read_unchecked::<::fidl_next::ServerEnd<
5596 ::fidl_next_fuchsia_io::Directory,
5597 ::fidl_next::wire::fuchsia::Channel,
5598 >>()
5599 });
5600
5601 let _ = self.table.get(3).map(|envelope| unsafe {
5602 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
5603 });
5604
5605 let _ = self.table.get(4).map(|envelope| unsafe {
5606 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
5607 });
5608 }
5609 }
5610
5611 impl ::fidl_next::Constrained for CapabilityStoreDirConnectorOpenRequest<'_> {
5612 type Constraint = ();
5613
5614 fn validate(
5615 _: ::fidl_next::Slot<'_, Self>,
5616 _: Self::Constraint,
5617 ) -> Result<(), ::fidl_next::ValidationError> {
5618 Ok(())
5619 }
5620 }
5621
5622 unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest<'static> {
5623 type Narrowed<'de> = CapabilityStoreDirConnectorOpenRequest<'de>;
5624
5625 #[inline]
5626 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5627 ::fidl_next::munge!(let Self { table } = out);
5628 ::fidl_next::wire::Table::zero_padding(table);
5629 }
5630 }
5631
5632 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest<'de>
5633 where
5634 ___D: ::fidl_next::Decoder<'de> + ?Sized,
5635 ___D: ::fidl_next::fuchsia::HandleDecoder,
5636 {
5637 fn decode(
5638 slot: ::fidl_next::Slot<'_, Self>,
5639 decoder: &mut ___D,
5640 _: (),
5641 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5642 ::fidl_next::munge!(let Self { table } = slot);
5643
5644 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5645 match ordinal {
5646 0 => unsafe { ::core::hint::unreachable_unchecked() },
5647
5648 1 => {
5649 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
5650 slot.as_mut(),
5651 decoder,
5652 (),
5653 )?;
5654
5655 Ok(())
5656 }
5657
5658 2 => {
5659 ::fidl_next::wire::Envelope::decode_as::<
5660 ___D,
5661 ::fidl_next::ServerEnd<
5662 ::fidl_next_fuchsia_io::Directory,
5663 ::fidl_next::wire::fuchsia::Channel,
5664 >,
5665 >(slot.as_mut(), decoder, ())?;
5666
5667 Ok(())
5668 }
5669
5670 3 => {
5671 ::fidl_next::wire::Envelope::decode_as::<
5672 ___D,
5673 ::fidl_next_fuchsia_io::wire::Flags,
5674 >(slot.as_mut(), decoder, ())?;
5675
5676 Ok(())
5677 }
5678
5679 4 => {
5680 ::fidl_next::wire::Envelope::decode_as::<
5681 ___D,
5682 ::fidl_next::wire::String<'de>,
5683 >(slot.as_mut(), decoder, 4095)?;
5684
5685 let value = unsafe {
5686 slot.deref_unchecked()
5687 .deref_unchecked::<::fidl_next::wire::String<'_>>()
5688 };
5689
5690 if value.len() > 4095 {
5691 return Err(::fidl_next::DecodeError::VectorTooLong {
5692 size: value.len() as u64,
5693 limit: 4095,
5694 });
5695 }
5696
5697 Ok(())
5698 }
5699
5700 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
5701 }
5702 })
5703 }
5704 }
5705
5706 impl<'de> CapabilityStoreDirConnectorOpenRequest<'de> {
5707 pub fn id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
5708 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5709 }
5710
5711 pub fn server_end(
5712 &self,
5713 ) -> ::core::option::Option<
5714 &::fidl_next::ServerEnd<
5715 ::fidl_next_fuchsia_io::Directory,
5716 ::fidl_next::wire::fuchsia::Channel,
5717 >,
5718 > {
5719 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5720 }
5721
5722 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
5723 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
5724 }
5725
5726 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
5727 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
5728 }
5729 }
5730
5731 impl<'de> ::core::fmt::Debug for CapabilityStoreDirConnectorOpenRequest<'de> {
5732 fn fmt(
5733 &self,
5734 f: &mut ::core::fmt::Formatter<'_>,
5735 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5736 f.debug_struct("CapabilityStoreDirConnectorOpenRequest")
5737 .field("id", &self.id())
5738 .field("server_end", &self.server_end())
5739 .field("flags", &self.flags())
5740 .field("path", &self.path())
5741 .finish()
5742 }
5743 }
5744
5745 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest<'de> {
5746 type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
5747 }
5748
5749 #[derive(Debug)]
5751 #[repr(C)]
5752 pub struct InstanceToken {
5753 pub token: ::fidl_next::wire::fuchsia::EventPair,
5754 }
5755
5756 static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
5757 static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
5758
5759 static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
5760
5761 impl ::fidl_next::Constrained for InstanceToken {
5762 type Constraint = ();
5763
5764 fn validate(
5765 _: ::fidl_next::Slot<'_, Self>,
5766 _: Self::Constraint,
5767 ) -> Result<(), ::fidl_next::ValidationError> {
5768 Ok(())
5769 }
5770 }
5771
5772 unsafe impl ::fidl_next::Wire for InstanceToken {
5773 type Narrowed<'de> = InstanceToken;
5774
5775 #[inline]
5776 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5777 ::fidl_next::munge! {
5778 let Self {
5779
5780 token,
5781
5782 } = &mut *out_;
5783 }
5784
5785 ::fidl_next::Wire::zero_padding(token);
5786 }
5787 }
5788
5789 unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
5790 where
5791 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5792 ___D: ::fidl_next::fuchsia::HandleDecoder,
5793 {
5794 fn decode(
5795 slot_: ::fidl_next::Slot<'_, Self>,
5796 decoder_: &mut ___D,
5797 _: (),
5798 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5799 ::fidl_next::munge! {
5800 let Self {
5801
5802 mut token,
5803
5804 } = slot_;
5805 }
5806
5807 let _field = token.as_mut();
5808
5809 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
5810
5811 Ok(())
5812 }
5813 }
5814
5815 impl ::fidl_next::IntoNatural for InstanceToken {
5816 type Natural = crate::natural::InstanceToken;
5817 }
5818
5819 #[repr(C)]
5821 pub struct RouteRequest<'de> {
5822 pub(crate) table: ::fidl_next::wire::Table<'de>,
5823 }
5824
5825 impl<'de> Drop for RouteRequest<'de> {
5826 fn drop(&mut self) {
5827 let _ = self
5828 .table
5829 .get(1)
5830 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
5831
5832 let _ = self
5833 .table
5834 .get(2)
5835 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
5836 }
5837 }
5838
5839 impl ::fidl_next::Constrained for RouteRequest<'_> {
5840 type Constraint = ();
5841
5842 fn validate(
5843 _: ::fidl_next::Slot<'_, Self>,
5844 _: Self::Constraint,
5845 ) -> Result<(), ::fidl_next::ValidationError> {
5846 Ok(())
5847 }
5848 }
5849
5850 unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
5851 type Narrowed<'de> = RouteRequest<'de>;
5852
5853 #[inline]
5854 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5855 ::fidl_next::munge!(let Self { table } = out);
5856 ::fidl_next::wire::Table::zero_padding(table);
5857 }
5858 }
5859
5860 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RouteRequest<'de>
5861 where
5862 ___D: ::fidl_next::Decoder<'de> + ?Sized,
5863 ___D: ::fidl_next::fuchsia::HandleDecoder,
5864 {
5865 fn decode(
5866 slot: ::fidl_next::Slot<'_, Self>,
5867 decoder: &mut ___D,
5868 _: (),
5869 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5870 ::fidl_next::munge!(let Self { table } = slot);
5871
5872 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5873 match ordinal {
5874 0 => unsafe { ::core::hint::unreachable_unchecked() },
5875
5876 1 => {
5877 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::InstanceToken>(
5878 slot.as_mut(),
5879 decoder,
5880 (),
5881 )?;
5882
5883 Ok(())
5884 }
5885
5886 2 => {
5887 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::DictionaryRef>(
5888 slot.as_mut(),
5889 decoder,
5890 (),
5891 )?;
5892
5893 Ok(())
5894 }
5895
5896 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
5897 }
5898 })
5899 }
5900 }
5901
5902 impl<'de> RouteRequest<'de> {
5903 pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
5904 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5905 }
5906
5907 pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
5908 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5909 }
5910 }
5911
5912 impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
5913 fn fmt(
5914 &self,
5915 f: &mut ::core::fmt::Formatter<'_>,
5916 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5917 f.debug_struct("RouteRequest")
5918 .field("requesting", &self.requesting())
5919 .field("metadata", &self.metadata())
5920 .finish()
5921 }
5922 }
5923
5924 impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
5925 type Natural = crate::natural::RouteRequest;
5926 }
5927
5928 #[repr(transparent)]
5930 pub struct ConnectorRouterRouteResponse {
5931 pub(crate) raw: ::fidl_next::wire::Union,
5932 pub(crate) _phantom: ::core::marker::PhantomData<()>,
5933 }
5934
5935 impl Drop for ConnectorRouterRouteResponse {
5936 fn drop(&mut self) {
5937 match self.raw.ordinal() {
5938 1 => {
5939 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
5940 }
5941
5942 2 => {
5943 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
5944 }
5945
5946 _ => unsafe { ::core::hint::unreachable_unchecked() },
5947 }
5948 }
5949 }
5950
5951 impl ::fidl_next::Constrained for ConnectorRouterRouteResponse {
5952 type Constraint = ();
5953
5954 fn validate(
5955 _: ::fidl_next::Slot<'_, Self>,
5956 _: Self::Constraint,
5957 ) -> Result<(), ::fidl_next::ValidationError> {
5958 Ok(())
5959 }
5960 }
5961
5962 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
5963 type Narrowed<'de> = ConnectorRouterRouteResponse;
5964
5965 #[inline]
5966 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5967 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
5968 ::fidl_next::wire::Union::zero_padding(raw);
5969 }
5970 }
5971
5972 pub mod connector_router_route_response {
5973 pub enum Ref<'de> {
5974 Connector(&'de crate::wire::Connector),
5975
5976 Unavailable(&'de crate::wire::Unit),
5977 }
5978 }
5979
5980 impl ConnectorRouterRouteResponse {
5981 pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
5982 match self.raw.ordinal() {
5983 1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
5984 self.raw.get().deref_unchecked::<crate::wire::Connector>()
5985 }),
5986
5987 2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
5988 self.raw.get().deref_unchecked::<crate::wire::Unit>()
5989 }),
5990
5991 _ => unsafe { ::core::hint::unreachable_unchecked() },
5992 }
5993 }
5994 }
5995
5996 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
5997 where
5998 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5999 ___D: ::fidl_next::fuchsia::HandleDecoder,
6000 {
6001 fn decode(
6002 mut slot: ::fidl_next::Slot<'_, Self>,
6003 decoder: &mut ___D,
6004 _: (),
6005 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6006 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6007 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6008 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Connector>(
6009 raw,
6010 decoder,
6011 (),
6012 )?,
6013
6014 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6015 raw,
6016 decoder,
6017 (),
6018 )?,
6019
6020 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6021 }
6022
6023 Ok(())
6024 }
6025 }
6026
6027 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
6028 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6029 match self.raw.ordinal() {
6030 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
6031 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6032 _ => unsafe { ::core::hint::unreachable_unchecked() },
6033 }
6034 }
6035 }
6036
6037 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
6038 type Natural = crate::natural::ConnectorRouterRouteResponse;
6039 }
6040
6041 #[repr(transparent)]
6043 pub struct DataRouterRouteResponse<'de> {
6044 pub(crate) raw: ::fidl_next::wire::Union,
6045 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6046 }
6047
6048 impl<'de> Drop for DataRouterRouteResponse<'de> {
6049 fn drop(&mut self) {
6050 match self.raw.ordinal() {
6051 1 => {
6052 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
6053 }
6054
6055 2 => {
6056 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6057 }
6058
6059 _ => unsafe { ::core::hint::unreachable_unchecked() },
6060 }
6061 }
6062 }
6063
6064 impl ::fidl_next::Constrained for DataRouterRouteResponse<'_> {
6065 type Constraint = ();
6066
6067 fn validate(
6068 _: ::fidl_next::Slot<'_, Self>,
6069 _: Self::Constraint,
6070 ) -> Result<(), ::fidl_next::ValidationError> {
6071 Ok(())
6072 }
6073 }
6074
6075 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
6076 type Narrowed<'de> = DataRouterRouteResponse<'de>;
6077
6078 #[inline]
6079 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6080 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6081 ::fidl_next::wire::Union::zero_padding(raw);
6082 }
6083 }
6084
6085 pub mod data_router_route_response {
6086 pub enum Ref<'de> {
6087 Data(&'de crate::wire::Data<'de>),
6088
6089 Unavailable(&'de crate::wire::Unit),
6090 }
6091 }
6092
6093 impl<'de> DataRouterRouteResponse<'de> {
6094 pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
6095 match self.raw.ordinal() {
6096 1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
6097 self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
6098 }),
6099
6100 2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
6101 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6102 }),
6103
6104 _ => unsafe { ::core::hint::unreachable_unchecked() },
6105 }
6106 }
6107 }
6108
6109 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'de>
6110 where
6111 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6112 ___D: ::fidl_next::Decoder<'de>,
6113 ___D: ::fidl_next::fuchsia::HandleDecoder,
6114 {
6115 fn decode(
6116 mut slot: ::fidl_next::Slot<'_, Self>,
6117 decoder: &mut ___D,
6118 _: (),
6119 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6120 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6121 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6122 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
6123 raw,
6124 decoder,
6125 (),
6126 )?,
6127
6128 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
6129 raw,
6130 decoder,
6131 (),
6132 )?,
6133
6134 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6135 }
6136
6137 Ok(())
6138 }
6139 }
6140
6141 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
6142 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6143 match self.raw.ordinal() {
6144 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
6145 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6146 _ => unsafe { ::core::hint::unreachable_unchecked() },
6147 }
6148 }
6149 }
6150
6151 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
6152 type Natural = crate::natural::DataRouterRouteResponse;
6153 }
6154
6155 #[derive(Debug)]
6157 #[repr(C)]
6158 pub struct DictionaryDrainIteratorGetNextResponse<'de> {
6159 pub items: ::fidl_next::wire::Vector<'de, crate::wire::DictionaryItem<'de>>,
6160
6161 pub end_id: ::fidl_next::wire::Uint64,
6162 }
6163
6164 static_assertions::const_assert_eq!(
6165 std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
6166 24
6167 );
6168 static_assertions::const_assert_eq!(
6169 std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
6170 8
6171 );
6172
6173 static_assertions::const_assert_eq!(
6174 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
6175 0
6176 );
6177
6178 static_assertions::const_assert_eq!(
6179 std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
6180 16
6181 );
6182
6183 impl ::fidl_next::Constrained for DictionaryDrainIteratorGetNextResponse<'_> {
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 DictionaryDrainIteratorGetNextResponse<'static> {
6195 type Narrowed<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
6196
6197 #[inline]
6198 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6199 ::fidl_next::munge! {
6200 let Self {
6201
6202 items,
6203 end_id,
6204
6205 } = &mut *out_;
6206 }
6207
6208 ::fidl_next::Wire::zero_padding(items);
6209
6210 ::fidl_next::Wire::zero_padding(end_id);
6211 }
6212 }
6213
6214 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'de>
6215 where
6216 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6217 ___D: ::fidl_next::Decoder<'de>,
6218 ___D: ::fidl_next::fuchsia::HandleDecoder,
6219 {
6220 fn decode(
6221 slot_: ::fidl_next::Slot<'_, Self>,
6222 decoder_: &mut ___D,
6223 _: (),
6224 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6225 ::fidl_next::munge! {
6226 let Self {
6227
6228 mut items,
6229 mut end_id,
6230
6231 } = slot_;
6232 }
6233
6234 let _field = items.as_mut();
6235 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6236 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
6237
6238 let items = unsafe { items.deref_unchecked() };
6239
6240 if items.len() > 128 {
6241 return Err(::fidl_next::DecodeError::VectorTooLong {
6242 size: items.len() as u64,
6243 limit: 128,
6244 });
6245 }
6246
6247 let _field = end_id.as_mut();
6248
6249 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6250
6251 Ok(())
6252 }
6253 }
6254
6255 impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
6256 type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
6257 }
6258
6259 #[derive(Debug)]
6261 #[repr(C)]
6262 pub struct DictionaryOptionalItem<'de> {
6263 pub key: ::fidl_next::wire::String<'de>,
6264
6265 pub value: ::fidl_next::wire::Box<'de, crate::wire::WrappedCapabilityId>,
6266 }
6267
6268 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
6269 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
6270
6271 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
6272
6273 static_assertions::const_assert_eq!(
6274 std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
6275 16
6276 );
6277
6278 impl ::fidl_next::Constrained for DictionaryOptionalItem<'_> {
6279 type Constraint = ();
6280
6281 fn validate(
6282 _: ::fidl_next::Slot<'_, Self>,
6283 _: Self::Constraint,
6284 ) -> Result<(), ::fidl_next::ValidationError> {
6285 Ok(())
6286 }
6287 }
6288
6289 unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
6290 type Narrowed<'de> = DictionaryOptionalItem<'de>;
6291
6292 #[inline]
6293 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6294 ::fidl_next::munge! {
6295 let Self {
6296
6297 key,
6298 value,
6299
6300 } = &mut *out_;
6301 }
6302
6303 ::fidl_next::Wire::zero_padding(key);
6304
6305 ::fidl_next::Wire::zero_padding(value);
6306 }
6307 }
6308
6309 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'de>
6310 where
6311 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6312 ___D: ::fidl_next::Decoder<'de>,
6313 ___D: ::fidl_next::fuchsia::HandleDecoder,
6314 {
6315 fn decode(
6316 slot_: ::fidl_next::Slot<'_, Self>,
6317 decoder_: &mut ___D,
6318 _: (),
6319 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6320 ::fidl_next::munge! {
6321 let Self {
6322
6323 mut key,
6324 mut value,
6325
6326 } = slot_;
6327 }
6328
6329 let _field = key.as_mut();
6330 ::fidl_next::Constrained::validate(_field, 255)?;
6331 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
6332
6333 let key = unsafe { key.deref_unchecked() };
6334
6335 if key.len() > 255 {
6336 return Err(::fidl_next::DecodeError::VectorTooLong {
6337 size: key.len() as u64,
6338 limit: 255,
6339 });
6340 }
6341
6342 let _field = value.as_mut();
6343
6344 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
6345
6346 Ok(())
6347 }
6348 }
6349
6350 impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
6351 type Natural = crate::natural::DictionaryOptionalItem;
6352 }
6353
6354 #[derive(Debug)]
6356 #[repr(C)]
6357 pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
6358 pub items: ::fidl_next::wire::Vector<'de, crate::wire::DictionaryOptionalItem<'de>>,
6359
6360 pub end_id: ::fidl_next::wire::Uint64,
6361 }
6362
6363 static_assertions::const_assert_eq!(
6364 std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6365 24
6366 );
6367 static_assertions::const_assert_eq!(
6368 std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
6369 8
6370 );
6371
6372 static_assertions::const_assert_eq!(
6373 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
6374 0
6375 );
6376
6377 static_assertions::const_assert_eq!(
6378 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
6379 16
6380 );
6381
6382 impl ::fidl_next::Constrained for DictionaryEnumerateIteratorGetNextResponse<'_> {
6383 type Constraint = ();
6384
6385 fn validate(
6386 _: ::fidl_next::Slot<'_, Self>,
6387 _: Self::Constraint,
6388 ) -> Result<(), ::fidl_next::ValidationError> {
6389 Ok(())
6390 }
6391 }
6392
6393 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
6394 type Narrowed<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
6395
6396 #[inline]
6397 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6398 ::fidl_next::munge! {
6399 let Self {
6400
6401 items,
6402 end_id,
6403
6404 } = &mut *out_;
6405 }
6406
6407 ::fidl_next::Wire::zero_padding(items);
6408
6409 ::fidl_next::Wire::zero_padding(end_id);
6410 }
6411 }
6412
6413 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'de>
6414 where
6415 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6416 ___D: ::fidl_next::Decoder<'de>,
6417 ___D: ::fidl_next::fuchsia::HandleDecoder,
6418 {
6419 fn decode(
6420 slot_: ::fidl_next::Slot<'_, Self>,
6421 decoder_: &mut ___D,
6422 _: (),
6423 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6424 ::fidl_next::munge! {
6425 let Self {
6426
6427 mut items,
6428 mut end_id,
6429
6430 } = slot_;
6431 }
6432
6433 let _field = items.as_mut();
6434 ::fidl_next::Constrained::validate(_field, (128, ()))?;
6435 ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
6436
6437 let items = unsafe { items.deref_unchecked() };
6438
6439 if items.len() > 128 {
6440 return Err(::fidl_next::DecodeError::VectorTooLong {
6441 size: items.len() as u64,
6442 limit: 128,
6443 });
6444 }
6445
6446 let _field = end_id.as_mut();
6447
6448 ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
6449
6450 Ok(())
6451 }
6452 }
6453
6454 impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
6455 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
6456 }
6457
6458 #[derive(Debug)]
6460 #[repr(C)]
6461 pub struct DictionaryKeysIteratorGetNextResponse<'de> {
6462 pub keys: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
6463 }
6464
6465 static_assertions::const_assert_eq!(
6466 std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6467 16
6468 );
6469 static_assertions::const_assert_eq!(
6470 std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
6471 8
6472 );
6473
6474 static_assertions::const_assert_eq!(
6475 std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
6476 0
6477 );
6478
6479 impl ::fidl_next::Constrained for DictionaryKeysIteratorGetNextResponse<'_> {
6480 type Constraint = ();
6481
6482 fn validate(
6483 _: ::fidl_next::Slot<'_, Self>,
6484 _: Self::Constraint,
6485 ) -> Result<(), ::fidl_next::ValidationError> {
6486 Ok(())
6487 }
6488 }
6489
6490 unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
6491 type Narrowed<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
6492
6493 #[inline]
6494 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6495 ::fidl_next::munge! {
6496 let Self {
6497
6498 keys,
6499
6500 } = &mut *out_;
6501 }
6502
6503 ::fidl_next::Wire::zero_padding(keys);
6504 }
6505 }
6506
6507 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'de>
6508 where
6509 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6510 ___D: ::fidl_next::Decoder<'de>,
6511 ___D: ::fidl_next::fuchsia::HandleDecoder,
6512 {
6513 fn decode(
6514 slot_: ::fidl_next::Slot<'_, Self>,
6515 decoder_: &mut ___D,
6516 _: (),
6517 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6518 ::fidl_next::munge! {
6519 let Self {
6520
6521 mut keys,
6522
6523 } = slot_;
6524 }
6525
6526 let _field = keys.as_mut();
6527 ::fidl_next::Constrained::validate(_field, (128, 255))?;
6528 ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
6529
6530 let keys = unsafe { keys.deref_unchecked() };
6531
6532 if keys.len() > 128 {
6533 return Err(::fidl_next::DecodeError::VectorTooLong {
6534 size: keys.len() as u64,
6535 limit: 128,
6536 });
6537 }
6538
6539 Ok(())
6540 }
6541 }
6542
6543 impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
6544 type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
6545 }
6546
6547 #[repr(transparent)]
6549 pub struct DictionaryRouterRouteResponse {
6550 pub(crate) raw: ::fidl_next::wire::Union,
6551 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6552 }
6553
6554 impl Drop for DictionaryRouterRouteResponse {
6555 fn drop(&mut self) {
6556 match self.raw.ordinal() {
6557 1 => {
6558 let _ =
6559 unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
6560 }
6561
6562 2 => {
6563 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6564 }
6565
6566 _ => unsafe { ::core::hint::unreachable_unchecked() },
6567 }
6568 }
6569 }
6570
6571 impl ::fidl_next::Constrained for DictionaryRouterRouteResponse {
6572 type Constraint = ();
6573
6574 fn validate(
6575 _: ::fidl_next::Slot<'_, Self>,
6576 _: Self::Constraint,
6577 ) -> Result<(), ::fidl_next::ValidationError> {
6578 Ok(())
6579 }
6580 }
6581
6582 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
6583 type Narrowed<'de> = DictionaryRouterRouteResponse;
6584
6585 #[inline]
6586 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6587 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6588 ::fidl_next::wire::Union::zero_padding(raw);
6589 }
6590 }
6591
6592 pub mod dictionary_router_route_response {
6593 pub enum Ref<'de> {
6594 Dictionary(&'de crate::wire::DictionaryRef),
6595
6596 Unavailable(&'de crate::wire::Unit),
6597 }
6598 }
6599
6600 impl DictionaryRouterRouteResponse {
6601 pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
6602 match self.raw.ordinal() {
6603 1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
6604 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
6605 }),
6606
6607 2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
6608 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6609 }),
6610
6611 _ => unsafe { ::core::hint::unreachable_unchecked() },
6612 }
6613 }
6614 }
6615
6616 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
6617 where
6618 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6619 ___D: ::fidl_next::fuchsia::HandleDecoder,
6620 {
6621 fn decode(
6622 mut slot: ::fidl_next::Slot<'_, Self>,
6623 decoder: &mut ___D,
6624 _: (),
6625 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6626 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6627 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6628 1 => {
6629 ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DictionaryRef>(
6630 raw,
6631 decoder,
6632 (),
6633 )?
6634 }
6635
6636 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6637 raw,
6638 decoder,
6639 (),
6640 )?,
6641
6642 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6643 }
6644
6645 Ok(())
6646 }
6647 }
6648
6649 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
6650 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6651 match self.raw.ordinal() {
6652 1 => unsafe {
6653 self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
6654 },
6655 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6656 _ => unsafe { ::core::hint::unreachable_unchecked() },
6657 }
6658 }
6659 }
6660
6661 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
6662 type Natural = crate::natural::DictionaryRouterRouteResponse;
6663 }
6664
6665 #[repr(transparent)]
6667 pub struct DirConnectorRouterRouteResponse {
6668 pub(crate) raw: ::fidl_next::wire::Union,
6669 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6670 }
6671
6672 impl Drop for DirConnectorRouterRouteResponse {
6673 fn drop(&mut self) {
6674 match self.raw.ordinal() {
6675 1 => {
6676 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
6677 }
6678
6679 2 => {
6680 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6681 }
6682
6683 _ => unsafe { ::core::hint::unreachable_unchecked() },
6684 }
6685 }
6686 }
6687
6688 impl ::fidl_next::Constrained for DirConnectorRouterRouteResponse {
6689 type Constraint = ();
6690
6691 fn validate(
6692 _: ::fidl_next::Slot<'_, Self>,
6693 _: Self::Constraint,
6694 ) -> Result<(), ::fidl_next::ValidationError> {
6695 Ok(())
6696 }
6697 }
6698
6699 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
6700 type Narrowed<'de> = DirConnectorRouterRouteResponse;
6701
6702 #[inline]
6703 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6704 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6705 ::fidl_next::wire::Union::zero_padding(raw);
6706 }
6707 }
6708
6709 pub mod dir_connector_router_route_response {
6710 pub enum Ref<'de> {
6711 DirConnector(&'de crate::wire::DirConnector),
6712
6713 Unavailable(&'de crate::wire::Unit),
6714 }
6715 }
6716
6717 impl DirConnectorRouterRouteResponse {
6718 pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
6719 match self.raw.ordinal() {
6720 1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
6721 self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
6722 }),
6723
6724 2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
6725 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6726 }),
6727
6728 _ => unsafe { ::core::hint::unreachable_unchecked() },
6729 }
6730 }
6731 }
6732
6733 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
6734 where
6735 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6736 ___D: ::fidl_next::fuchsia::HandleDecoder,
6737 {
6738 fn decode(
6739 mut slot: ::fidl_next::Slot<'_, Self>,
6740 decoder: &mut ___D,
6741 _: (),
6742 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6743 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6744 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6745 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirConnector>(
6746 raw,
6747 decoder,
6748 (),
6749 )?,
6750
6751 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6752 raw,
6753 decoder,
6754 (),
6755 )?,
6756
6757 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6758 }
6759
6760 Ok(())
6761 }
6762 }
6763
6764 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
6765 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6766 match self.raw.ordinal() {
6767 1 => unsafe {
6768 self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
6769 },
6770 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6771 _ => unsafe { ::core::hint::unreachable_unchecked() },
6772 }
6773 }
6774 }
6775
6776 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
6777 type Natural = crate::natural::DirConnectorRouterRouteResponse;
6778 }
6779
6780 #[repr(transparent)]
6782 pub struct DirEntryRouterRouteResponse {
6783 pub(crate) raw: ::fidl_next::wire::Union,
6784 pub(crate) _phantom: ::core::marker::PhantomData<()>,
6785 }
6786
6787 impl Drop for DirEntryRouterRouteResponse {
6788 fn drop(&mut self) {
6789 match self.raw.ordinal() {
6790 1 => {
6791 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
6792 }
6793
6794 2 => {
6795 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
6796 }
6797
6798 _ => unsafe { ::core::hint::unreachable_unchecked() },
6799 }
6800 }
6801 }
6802
6803 impl ::fidl_next::Constrained for DirEntryRouterRouteResponse {
6804 type Constraint = ();
6805
6806 fn validate(
6807 _: ::fidl_next::Slot<'_, Self>,
6808 _: Self::Constraint,
6809 ) -> Result<(), ::fidl_next::ValidationError> {
6810 Ok(())
6811 }
6812 }
6813
6814 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
6815 type Narrowed<'de> = DirEntryRouterRouteResponse;
6816
6817 #[inline]
6818 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6819 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6820 ::fidl_next::wire::Union::zero_padding(raw);
6821 }
6822 }
6823
6824 pub mod dir_entry_router_route_response {
6825 pub enum Ref<'de> {
6826 DirEntry(&'de crate::wire::DirEntry),
6827
6828 Unavailable(&'de crate::wire::Unit),
6829 }
6830 }
6831
6832 impl DirEntryRouterRouteResponse {
6833 pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
6834 match self.raw.ordinal() {
6835 1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
6836 self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
6837 }),
6838
6839 2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
6840 self.raw.get().deref_unchecked::<crate::wire::Unit>()
6841 }),
6842
6843 _ => unsafe { ::core::hint::unreachable_unchecked() },
6844 }
6845 }
6846 }
6847
6848 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
6849 where
6850 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6851 ___D: ::fidl_next::fuchsia::HandleDecoder,
6852 {
6853 fn decode(
6854 mut slot: ::fidl_next::Slot<'_, Self>,
6855 decoder: &mut ___D,
6856 _: (),
6857 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6858 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6859 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6860 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirEntry>(
6861 raw,
6862 decoder,
6863 (),
6864 )?,
6865
6866 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
6867 raw,
6868 decoder,
6869 (),
6870 )?,
6871
6872 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
6873 }
6874
6875 Ok(())
6876 }
6877 }
6878
6879 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
6880 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6881 match self.raw.ordinal() {
6882 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
6883 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
6884 _ => unsafe { ::core::hint::unreachable_unchecked() },
6885 }
6886 }
6887 }
6888
6889 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
6890 type Natural = crate::natural::DirEntryRouterRouteResponse;
6891 }
6892
6893 #[repr(C)]
6895 pub struct DirReceiverReceiveRequest<'de> {
6896 pub(crate) table: ::fidl_next::wire::Table<'de>,
6897 }
6898
6899 impl<'de> Drop for DirReceiverReceiveRequest<'de> {
6900 fn drop(&mut self) {
6901 let _ = self.table.get(1).map(|envelope| unsafe {
6902 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
6903 });
6904
6905 let _ = self.table.get(2).map(|envelope| unsafe {
6906 envelope.read_unchecked::<::fidl_next_fuchsia_io::wire::Flags>()
6907 });
6908
6909 let _ = self.table.get(3).map(|envelope| unsafe {
6910 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
6911 });
6912 }
6913 }
6914
6915 impl ::fidl_next::Constrained for DirReceiverReceiveRequest<'_> {
6916 type Constraint = ();
6917
6918 fn validate(
6919 _: ::fidl_next::Slot<'_, Self>,
6920 _: Self::Constraint,
6921 ) -> Result<(), ::fidl_next::ValidationError> {
6922 Ok(())
6923 }
6924 }
6925
6926 unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest<'static> {
6927 type Narrowed<'de> = DirReceiverReceiveRequest<'de>;
6928
6929 #[inline]
6930 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6931 ::fidl_next::munge!(let Self { table } = out);
6932 ::fidl_next::wire::Table::zero_padding(table);
6933 }
6934 }
6935
6936 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest<'de>
6937 where
6938 ___D: ::fidl_next::Decoder<'de> + ?Sized,
6939 ___D: ::fidl_next::fuchsia::HandleDecoder,
6940 {
6941 fn decode(
6942 slot: ::fidl_next::Slot<'_, Self>,
6943 decoder: &mut ___D,
6944 _: (),
6945 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6946 ::fidl_next::munge!(let Self { table } = slot);
6947
6948 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
6949 match ordinal {
6950 0 => unsafe { ::core::hint::unreachable_unchecked() },
6951
6952 1 => {
6953 ::fidl_next::wire::Envelope::decode_as::<
6954 ___D,
6955 ::fidl_next::wire::fuchsia::Channel,
6956 >(slot.as_mut(), decoder, ())?;
6957
6958 Ok(())
6959 }
6960
6961 2 => {
6962 ::fidl_next::wire::Envelope::decode_as::<
6963 ___D,
6964 ::fidl_next_fuchsia_io::wire::Flags,
6965 >(slot.as_mut(), decoder, ())?;
6966
6967 Ok(())
6968 }
6969
6970 3 => {
6971 ::fidl_next::wire::Envelope::decode_as::<
6972 ___D,
6973 ::fidl_next::wire::String<'de>,
6974 >(slot.as_mut(), decoder, 4095)?;
6975
6976 let value = unsafe {
6977 slot.deref_unchecked()
6978 .deref_unchecked::<::fidl_next::wire::String<'_>>()
6979 };
6980
6981 if value.len() > 4095 {
6982 return Err(::fidl_next::DecodeError::VectorTooLong {
6983 size: value.len() as u64,
6984 limit: 4095,
6985 });
6986 }
6987
6988 Ok(())
6989 }
6990
6991 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
6992 }
6993 })
6994 }
6995 }
6996
6997 impl<'de> DirReceiverReceiveRequest<'de> {
6998 pub fn channel(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
6999 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
7000 }
7001
7002 pub fn flags(&self) -> ::core::option::Option<&::fidl_next_fuchsia_io::wire::Flags> {
7003 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
7004 }
7005
7006 pub fn subdir(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
7007 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
7008 }
7009 }
7010
7011 impl<'de> ::core::fmt::Debug for DirReceiverReceiveRequest<'de> {
7012 fn fmt(
7013 &self,
7014 f: &mut ::core::fmt::Formatter<'_>,
7015 ) -> ::core::result::Result<(), ::core::fmt::Error> {
7016 f.debug_struct("DirReceiverReceiveRequest")
7017 .field("channel", &self.channel())
7018 .field("flags", &self.flags())
7019 .field("subdir", &self.subdir())
7020 .finish()
7021 }
7022 }
7023
7024 impl<'de> ::fidl_next::IntoNatural for DirReceiverReceiveRequest<'de> {
7025 type Natural = crate::natural::DirReceiverReceiveRequest;
7026 }
7027
7028 #[repr(transparent)]
7030 pub struct DirectoryRouterRouteResponse {
7031 pub(crate) raw: ::fidl_next::wire::Union,
7032 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7033 }
7034
7035 impl Drop for DirectoryRouterRouteResponse {
7036 fn drop(&mut self) {
7037 match self.raw.ordinal() {
7038 1 => {
7039 let _ = unsafe {
7040 self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
7041 ::fidl_next_fuchsia_io::Directory,
7042 ::fidl_next::wire::fuchsia::Channel,
7043 >>()
7044 };
7045 }
7046
7047 2 => {
7048 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
7049 }
7050
7051 _ => unsafe { ::core::hint::unreachable_unchecked() },
7052 }
7053 }
7054 }
7055
7056 impl ::fidl_next::Constrained for DirectoryRouterRouteResponse {
7057 type Constraint = ();
7058
7059 fn validate(
7060 _: ::fidl_next::Slot<'_, Self>,
7061 _: Self::Constraint,
7062 ) -> Result<(), ::fidl_next::ValidationError> {
7063 Ok(())
7064 }
7065 }
7066
7067 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
7068 type Narrowed<'de> = DirectoryRouterRouteResponse;
7069
7070 #[inline]
7071 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7072 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7073 ::fidl_next::wire::Union::zero_padding(raw);
7074 }
7075 }
7076
7077 pub mod directory_router_route_response {
7078 pub enum Ref<'de> {
7079 Directory(
7080 &'de ::fidl_next::ClientEnd<
7081 ::fidl_next_fuchsia_io::Directory,
7082 ::fidl_next::wire::fuchsia::Channel,
7083 >,
7084 ),
7085
7086 Unavailable(&'de crate::wire::Unit),
7087 }
7088 }
7089
7090 impl DirectoryRouterRouteResponse {
7091 pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
7092 match self.raw.ordinal() {
7093 1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
7094 self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
7095 ::fidl_next_fuchsia_io::Directory,
7096 ::fidl_next::wire::fuchsia::Channel,
7097 >>()
7098 }),
7099
7100 2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
7101 self.raw.get().deref_unchecked::<crate::wire::Unit>()
7102 }),
7103
7104 _ => unsafe { ::core::hint::unreachable_unchecked() },
7105 }
7106 }
7107 }
7108
7109 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
7110 where
7111 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7112 ___D: ::fidl_next::fuchsia::HandleDecoder,
7113 {
7114 fn decode(
7115 mut slot: ::fidl_next::Slot<'_, Self>,
7116 decoder: &mut ___D,
7117 _: (),
7118 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7119 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7120 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7121 1 => ::fidl_next::wire::Union::decode_as_static::<
7122 ___D,
7123 ::fidl_next::ClientEnd<
7124 ::fidl_next_fuchsia_io::Directory,
7125 ::fidl_next::wire::fuchsia::Channel,
7126 >,
7127 >(raw, decoder, ())?,
7128
7129 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7130 raw,
7131 decoder,
7132 (),
7133 )?,
7134
7135 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
7136 }
7137
7138 Ok(())
7139 }
7140 }
7141
7142 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
7143 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7144 match self.raw.ordinal() {
7145 1 => unsafe {
7146 self.raw
7147 .get()
7148 .deref_unchecked::<::fidl_next::ClientEnd<
7149 ::fidl_next_fuchsia_io::Directory,
7150 ::fidl_next::wire::fuchsia::Channel,
7151 >>()
7152 .fmt(f)
7153 },
7154 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
7155 _ => unsafe { ::core::hint::unreachable_unchecked() },
7156 }
7157 }
7158 }
7159
7160 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
7161 type Natural = crate::natural::DirectoryRouterRouteResponse;
7162 }
7163
7164 #[derive(Debug)]
7166 #[repr(C)]
7167 pub struct ProtocolPayload {
7168 pub channel: ::fidl_next::wire::fuchsia::Channel,
7169 }
7170
7171 static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
7172 static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
7173
7174 static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
7175
7176 impl ::fidl_next::Constrained for ProtocolPayload {
7177 type Constraint = ();
7178
7179 fn validate(
7180 _: ::fidl_next::Slot<'_, Self>,
7181 _: Self::Constraint,
7182 ) -> Result<(), ::fidl_next::ValidationError> {
7183 Ok(())
7184 }
7185 }
7186
7187 unsafe impl ::fidl_next::Wire for ProtocolPayload {
7188 type Narrowed<'de> = ProtocolPayload;
7189
7190 #[inline]
7191 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
7192 ::fidl_next::munge! {
7193 let Self {
7194
7195 channel,
7196
7197 } = &mut *out_;
7198 }
7199
7200 ::fidl_next::Wire::zero_padding(channel);
7201 }
7202 }
7203
7204 unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
7205 where
7206 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7207 ___D: ::fidl_next::fuchsia::HandleDecoder,
7208 {
7209 fn decode(
7210 slot_: ::fidl_next::Slot<'_, Self>,
7211 decoder_: &mut ___D,
7212 _: (),
7213 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7214 ::fidl_next::munge! {
7215 let Self {
7216
7217 mut channel,
7218
7219 } = slot_;
7220 }
7221
7222 let _field = channel.as_mut();
7223
7224 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
7225
7226 Ok(())
7227 }
7228 }
7229
7230 impl ::fidl_next::IntoNatural for ProtocolPayload {
7231 type Natural = crate::natural::ProtocolPayload;
7232 }
7233}
7234
7235pub mod wire_optional {
7236
7237 pub use fidl_next_common_fuchsia_component_sandbox::wire_optional::*;
7238
7239 #[repr(transparent)]
7240 pub struct Capability<'de> {
7241 pub(crate) raw: ::fidl_next::wire::Union,
7242 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
7243 }
7244
7245 impl ::fidl_next::Constrained for Capability<'_> {
7246 type Constraint = ();
7247
7248 fn validate(
7249 _: ::fidl_next::Slot<'_, Self>,
7250 _: Self::Constraint,
7251 ) -> Result<(), ::fidl_next::ValidationError> {
7252 Ok(())
7253 }
7254 }
7255
7256 unsafe impl ::fidl_next::Wire for Capability<'static> {
7257 type Narrowed<'de> = Capability<'de>;
7258
7259 #[inline]
7260 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7261 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7262 ::fidl_next::wire::Union::zero_padding(raw);
7263 }
7264 }
7265
7266 impl<'de> Capability<'de> {
7267 pub fn is_some(&self) -> bool {
7268 self.raw.is_some()
7269 }
7270
7271 pub fn is_none(&self) -> bool {
7272 self.raw.is_none()
7273 }
7274
7275 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
7276 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7277 }
7278
7279 pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
7280 if self.is_some() {
7281 Some(crate::wire::Capability {
7282 raw: self.raw,
7283 _phantom: ::core::marker::PhantomData,
7284 })
7285 } else {
7286 None
7287 }
7288 }
7289 }
7290
7291 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Capability<'de>
7292 where
7293 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7294 ___D: ::fidl_next::Decoder<'de>,
7295 ___D: ::fidl_next::fuchsia::HandleDecoder,
7296 {
7297 fn decode(
7298 mut slot: ::fidl_next::Slot<'_, Self>,
7299 decoder: &mut ___D,
7300 _: (),
7301 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7302 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7303 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7304 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
7305 raw,
7306 decoder,
7307 (),
7308 )?,
7309
7310 2 => ::fidl_next::wire::Union::decode_as::<
7311 ___D,
7312 ::fidl_next::wire::fuchsia::NullableHandle,
7313 >(raw, decoder, ())?,
7314
7315 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
7316 raw,
7317 decoder,
7318 (),
7319 )?,
7320
7321 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DictionaryRef>(
7322 raw,
7323 decoder,
7324 (),
7325 )?,
7326
7327 5 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Connector>(
7328 raw,
7329 decoder,
7330 (),
7331 )?,
7332
7333 6 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirConnector>(
7334 raw,
7335 decoder,
7336 (),
7337 )?,
7338
7339 7 => ::fidl_next::wire::Union::decode_as::<
7340 ___D,
7341 ::fidl_next::ClientEnd<
7342 ::fidl_next_fuchsia_io::Directory,
7343 ::fidl_next::wire::fuchsia::Channel,
7344 >,
7345 >(raw, decoder, ())?,
7346
7347 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirEntry>(
7348 raw,
7349 decoder,
7350 (),
7351 )?,
7352
7353 9 => ::fidl_next::wire::Union::decode_as::<
7354 ___D,
7355 ::fidl_next::ClientEnd<
7356 crate::ConnectorRouter,
7357 ::fidl_next::wire::fuchsia::Channel,
7358 >,
7359 >(raw, decoder, ())?,
7360
7361 10 => ::fidl_next::wire::Union::decode_as::<
7362 ___D,
7363 ::fidl_next::ClientEnd<
7364 crate::DictionaryRouter,
7365 ::fidl_next::wire::fuchsia::Channel,
7366 >,
7367 >(raw, decoder, ())?,
7368
7369 11 => ::fidl_next::wire::Union::decode_as::<
7370 ___D,
7371 ::fidl_next::ClientEnd<
7372 crate::DirEntryRouter,
7373 ::fidl_next::wire::fuchsia::Channel,
7374 >,
7375 >(raw, decoder, ())?,
7376
7377 12 => ::fidl_next::wire::Union::decode_as::<
7378 ___D,
7379 ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::wire::fuchsia::Channel>,
7380 >(raw, decoder, ())?,
7381
7382 13 => ::fidl_next::wire::Union::decode_as::<
7383 ___D,
7384 ::fidl_next::ClientEnd<
7385 crate::DirConnectorRouter,
7386 ::fidl_next::wire::fuchsia::Channel,
7387 >,
7388 >(raw, decoder, ())?,
7389
7390 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7391 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
7392 }
7393
7394 Ok(())
7395 }
7396 }
7397
7398 impl<'de> ::core::fmt::Debug for Capability<'de> {
7399 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7400 self.as_ref().fmt(f)
7401 }
7402 }
7403
7404 impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
7405 type Natural = ::core::option::Option<crate::natural::Capability>;
7406 }
7407
7408 #[repr(transparent)]
7409 pub struct ConnectorRouterRouteResponse {
7410 pub(crate) raw: ::fidl_next::wire::Union,
7411 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7412 }
7413
7414 impl ::fidl_next::Constrained for ConnectorRouterRouteResponse {
7415 type Constraint = ();
7416
7417 fn validate(
7418 _: ::fidl_next::Slot<'_, Self>,
7419 _: Self::Constraint,
7420 ) -> Result<(), ::fidl_next::ValidationError> {
7421 Ok(())
7422 }
7423 }
7424
7425 unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
7426 type Narrowed<'de> = ConnectorRouterRouteResponse;
7427
7428 #[inline]
7429 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7430 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7431 ::fidl_next::wire::Union::zero_padding(raw);
7432 }
7433 }
7434
7435 impl ConnectorRouterRouteResponse {
7436 pub fn is_some(&self) -> bool {
7437 self.raw.is_some()
7438 }
7439
7440 pub fn is_none(&self) -> bool {
7441 self.raw.is_none()
7442 }
7443
7444 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
7445 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7446 }
7447
7448 pub fn into_option(
7449 self,
7450 ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
7451 if self.is_some() {
7452 Some(crate::wire::ConnectorRouterRouteResponse {
7453 raw: self.raw,
7454 _phantom: ::core::marker::PhantomData,
7455 })
7456 } else {
7457 None
7458 }
7459 }
7460 }
7461
7462 unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
7463 where
7464 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7465 ___D: ::fidl_next::fuchsia::HandleDecoder,
7466 {
7467 fn decode(
7468 mut slot: ::fidl_next::Slot<'_, Self>,
7469 decoder: &mut ___D,
7470 _: (),
7471 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7472 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7473 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7474 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Connector>(
7475 raw,
7476 decoder,
7477 (),
7478 )?,
7479
7480 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7481 raw,
7482 decoder,
7483 (),
7484 )?,
7485
7486 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7487 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7488 }
7489
7490 Ok(())
7491 }
7492 }
7493
7494 impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
7495 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7496 self.as_ref().fmt(f)
7497 }
7498 }
7499
7500 impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
7501 type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
7502 }
7503
7504 #[repr(transparent)]
7505 pub struct DataRouterRouteResponse<'de> {
7506 pub(crate) raw: ::fidl_next::wire::Union,
7507 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
7508 }
7509
7510 impl ::fidl_next::Constrained for DataRouterRouteResponse<'_> {
7511 type Constraint = ();
7512
7513 fn validate(
7514 _: ::fidl_next::Slot<'_, Self>,
7515 _: Self::Constraint,
7516 ) -> Result<(), ::fidl_next::ValidationError> {
7517 Ok(())
7518 }
7519 }
7520
7521 unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
7522 type Narrowed<'de> = DataRouterRouteResponse<'de>;
7523
7524 #[inline]
7525 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7526 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7527 ::fidl_next::wire::Union::zero_padding(raw);
7528 }
7529 }
7530
7531 impl<'de> DataRouterRouteResponse<'de> {
7532 pub fn is_some(&self) -> bool {
7533 self.raw.is_some()
7534 }
7535
7536 pub fn is_none(&self) -> bool {
7537 self.raw.is_none()
7538 }
7539
7540 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
7541 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7542 }
7543
7544 pub fn into_option(
7545 self,
7546 ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
7547 if self.is_some() {
7548 Some(crate::wire::DataRouterRouteResponse {
7549 raw: self.raw,
7550 _phantom: ::core::marker::PhantomData,
7551 })
7552 } else {
7553 None
7554 }
7555 }
7556 }
7557
7558 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'de>
7559 where
7560 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7561 ___D: ::fidl_next::Decoder<'de>,
7562 ___D: ::fidl_next::fuchsia::HandleDecoder,
7563 {
7564 fn decode(
7565 mut slot: ::fidl_next::Slot<'_, Self>,
7566 decoder: &mut ___D,
7567 _: (),
7568 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7569 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7570 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7571 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Data<'de>>(
7572 raw,
7573 decoder,
7574 (),
7575 )?,
7576
7577 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Unit>(
7578 raw,
7579 decoder,
7580 (),
7581 )?,
7582
7583 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7584 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
7585 }
7586
7587 Ok(())
7588 }
7589 }
7590
7591 impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
7592 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7593 self.as_ref().fmt(f)
7594 }
7595 }
7596
7597 impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
7598 type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
7599 }
7600
7601 #[repr(transparent)]
7602 pub struct DictionaryRouterRouteResponse {
7603 pub(crate) raw: ::fidl_next::wire::Union,
7604 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7605 }
7606
7607 impl ::fidl_next::Constrained for DictionaryRouterRouteResponse {
7608 type Constraint = ();
7609
7610 fn validate(
7611 _: ::fidl_next::Slot<'_, Self>,
7612 _: Self::Constraint,
7613 ) -> Result<(), ::fidl_next::ValidationError> {
7614 Ok(())
7615 }
7616 }
7617
7618 unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
7619 type Narrowed<'de> = DictionaryRouterRouteResponse;
7620
7621 #[inline]
7622 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7623 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7624 ::fidl_next::wire::Union::zero_padding(raw);
7625 }
7626 }
7627
7628 impl DictionaryRouterRouteResponse {
7629 pub fn is_some(&self) -> bool {
7630 self.raw.is_some()
7631 }
7632
7633 pub fn is_none(&self) -> bool {
7634 self.raw.is_none()
7635 }
7636
7637 pub fn as_ref(
7638 &self,
7639 ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
7640 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7641 }
7642
7643 pub fn into_option(
7644 self,
7645 ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
7646 if self.is_some() {
7647 Some(crate::wire::DictionaryRouterRouteResponse {
7648 raw: self.raw,
7649 _phantom: ::core::marker::PhantomData,
7650 })
7651 } else {
7652 None
7653 }
7654 }
7655 }
7656
7657 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
7658 where
7659 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7660 ___D: ::fidl_next::fuchsia::HandleDecoder,
7661 {
7662 fn decode(
7663 mut slot: ::fidl_next::Slot<'_, Self>,
7664 decoder: &mut ___D,
7665 _: (),
7666 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7667 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7668 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7669 1 => {
7670 ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DictionaryRef>(
7671 raw,
7672 decoder,
7673 (),
7674 )?
7675 }
7676
7677 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7678 raw,
7679 decoder,
7680 (),
7681 )?,
7682
7683 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7684 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7685 }
7686
7687 Ok(())
7688 }
7689 }
7690
7691 impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
7692 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7693 self.as_ref().fmt(f)
7694 }
7695 }
7696
7697 impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
7698 type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
7699 }
7700
7701 #[repr(transparent)]
7702 pub struct DirConnectorRouterRouteResponse {
7703 pub(crate) raw: ::fidl_next::wire::Union,
7704 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7705 }
7706
7707 impl ::fidl_next::Constrained for DirConnectorRouterRouteResponse {
7708 type Constraint = ();
7709
7710 fn validate(
7711 _: ::fidl_next::Slot<'_, Self>,
7712 _: Self::Constraint,
7713 ) -> Result<(), ::fidl_next::ValidationError> {
7714 Ok(())
7715 }
7716 }
7717
7718 unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
7719 type Narrowed<'de> = DirConnectorRouterRouteResponse;
7720
7721 #[inline]
7722 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7723 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7724 ::fidl_next::wire::Union::zero_padding(raw);
7725 }
7726 }
7727
7728 impl DirConnectorRouterRouteResponse {
7729 pub fn is_some(&self) -> bool {
7730 self.raw.is_some()
7731 }
7732
7733 pub fn is_none(&self) -> bool {
7734 self.raw.is_none()
7735 }
7736
7737 pub fn as_ref(
7738 &self,
7739 ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
7740 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7741 }
7742
7743 pub fn into_option(
7744 self,
7745 ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
7746 if self.is_some() {
7747 Some(crate::wire::DirConnectorRouterRouteResponse {
7748 raw: self.raw,
7749 _phantom: ::core::marker::PhantomData,
7750 })
7751 } else {
7752 None
7753 }
7754 }
7755 }
7756
7757 unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
7758 where
7759 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7760 ___D: ::fidl_next::fuchsia::HandleDecoder,
7761 {
7762 fn decode(
7763 mut slot: ::fidl_next::Slot<'_, Self>,
7764 decoder: &mut ___D,
7765 _: (),
7766 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7767 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7768 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7769 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirConnector>(
7770 raw,
7771 decoder,
7772 (),
7773 )?,
7774
7775 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7776 raw,
7777 decoder,
7778 (),
7779 )?,
7780
7781 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7782 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7783 }
7784
7785 Ok(())
7786 }
7787 }
7788
7789 impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
7790 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7791 self.as_ref().fmt(f)
7792 }
7793 }
7794
7795 impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
7796 type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
7797 }
7798
7799 #[repr(transparent)]
7800 pub struct DirEntryRouterRouteResponse {
7801 pub(crate) raw: ::fidl_next::wire::Union,
7802 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7803 }
7804
7805 impl ::fidl_next::Constrained for DirEntryRouterRouteResponse {
7806 type Constraint = ();
7807
7808 fn validate(
7809 _: ::fidl_next::Slot<'_, Self>,
7810 _: Self::Constraint,
7811 ) -> Result<(), ::fidl_next::ValidationError> {
7812 Ok(())
7813 }
7814 }
7815
7816 unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
7817 type Narrowed<'de> = DirEntryRouterRouteResponse;
7818
7819 #[inline]
7820 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7821 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7822 ::fidl_next::wire::Union::zero_padding(raw);
7823 }
7824 }
7825
7826 impl DirEntryRouterRouteResponse {
7827 pub fn is_some(&self) -> bool {
7828 self.raw.is_some()
7829 }
7830
7831 pub fn is_none(&self) -> bool {
7832 self.raw.is_none()
7833 }
7834
7835 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
7836 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7837 }
7838
7839 pub fn into_option(
7840 self,
7841 ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
7842 if self.is_some() {
7843 Some(crate::wire::DirEntryRouterRouteResponse {
7844 raw: self.raw,
7845 _phantom: ::core::marker::PhantomData,
7846 })
7847 } else {
7848 None
7849 }
7850 }
7851 }
7852
7853 unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
7854 where
7855 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7856 ___D: ::fidl_next::fuchsia::HandleDecoder,
7857 {
7858 fn decode(
7859 mut slot: ::fidl_next::Slot<'_, Self>,
7860 decoder: &mut ___D,
7861 _: (),
7862 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7863 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7864 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7865 1 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::DirEntry>(
7866 raw,
7867 decoder,
7868 (),
7869 )?,
7870
7871 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7872 raw,
7873 decoder,
7874 (),
7875 )?,
7876
7877 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7878 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7879 }
7880
7881 Ok(())
7882 }
7883 }
7884
7885 impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
7886 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7887 self.as_ref().fmt(f)
7888 }
7889 }
7890
7891 impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
7892 type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
7893 }
7894
7895 #[repr(transparent)]
7896 pub struct DirectoryRouterRouteResponse {
7897 pub(crate) raw: ::fidl_next::wire::Union,
7898 pub(crate) _phantom: ::core::marker::PhantomData<()>,
7899 }
7900
7901 impl ::fidl_next::Constrained for DirectoryRouterRouteResponse {
7902 type Constraint = ();
7903
7904 fn validate(
7905 _: ::fidl_next::Slot<'_, Self>,
7906 _: Self::Constraint,
7907 ) -> Result<(), ::fidl_next::ValidationError> {
7908 Ok(())
7909 }
7910 }
7911
7912 unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
7913 type Narrowed<'de> = DirectoryRouterRouteResponse;
7914
7915 #[inline]
7916 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
7917 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
7918 ::fidl_next::wire::Union::zero_padding(raw);
7919 }
7920 }
7921
7922 impl DirectoryRouterRouteResponse {
7923 pub fn is_some(&self) -> bool {
7924 self.raw.is_some()
7925 }
7926
7927 pub fn is_none(&self) -> bool {
7928 self.raw.is_none()
7929 }
7930
7931 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
7932 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
7933 }
7934
7935 pub fn into_option(
7936 self,
7937 ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
7938 if self.is_some() {
7939 Some(crate::wire::DirectoryRouterRouteResponse {
7940 raw: self.raw,
7941 _phantom: ::core::marker::PhantomData,
7942 })
7943 } else {
7944 None
7945 }
7946 }
7947 }
7948
7949 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
7950 where
7951 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
7952 ___D: ::fidl_next::fuchsia::HandleDecoder,
7953 {
7954 fn decode(
7955 mut slot: ::fidl_next::Slot<'_, Self>,
7956 decoder: &mut ___D,
7957 _: (),
7958 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
7959 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
7960 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
7961 1 => ::fidl_next::wire::Union::decode_as_static::<
7962 ___D,
7963 ::fidl_next::ClientEnd<
7964 ::fidl_next_fuchsia_io::Directory,
7965 ::fidl_next::wire::fuchsia::Channel,
7966 >,
7967 >(raw, decoder, ())?,
7968
7969 2 => ::fidl_next::wire::Union::decode_as_static::<___D, crate::wire::Unit>(
7970 raw,
7971 decoder,
7972 (),
7973 )?,
7974
7975 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
7976 _ => ::fidl_next::wire::Union::decode_unknown_static(raw, decoder)?,
7977 }
7978
7979 Ok(())
7980 }
7981 }
7982
7983 impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
7984 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7985 self.as_ref().fmt(f)
7986 }
7987 }
7988
7989 impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
7990 type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
7991 }
7992}
7993
7994pub mod generic {
7995
7996 pub use fidl_next_common_fuchsia_component_sandbox::generic::*;
7997
7998 pub struct DirConnector<T0> {
7999 pub token: T0,
8000 }
8001
8002 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirConnector, ___E> for DirConnector<T0>
8003 where
8004 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8005 ___E: ::fidl_next::fuchsia::HandleEncoder,
8006 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8007 {
8008 #[inline]
8009 fn encode(
8010 self,
8011 encoder_: &mut ___E,
8012 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirConnector>,
8013 _: (),
8014 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8015 ::fidl_next::munge! {
8016 let crate::wire::DirConnector {
8017
8018 token,
8019
8020 } = out_;
8021 }
8022
8023 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8024
8025 Ok(())
8026 }
8027 }
8028
8029 pub struct DictionaryRef<T0> {
8030 pub token: T0,
8031 }
8032
8033 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DictionaryRef, ___E> for DictionaryRef<T0>
8034 where
8035 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8036 ___E: ::fidl_next::fuchsia::HandleEncoder,
8037 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8038 {
8039 #[inline]
8040 fn encode(
8041 self,
8042 encoder_: &mut ___E,
8043 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryRef>,
8044 _: (),
8045 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8046 ::fidl_next::munge! {
8047 let crate::wire::DictionaryRef {
8048
8049 token,
8050
8051 } = out_;
8052 }
8053
8054 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8055
8056 Ok(())
8057 }
8058 }
8059
8060 pub struct Connector<T0> {
8061 pub token: T0,
8062 }
8063
8064 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::Connector, ___E> for Connector<T0>
8065 where
8066 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8067 ___E: ::fidl_next::fuchsia::HandleEncoder,
8068 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8069 {
8070 #[inline]
8071 fn encode(
8072 self,
8073 encoder_: &mut ___E,
8074 out_: &mut ::core::mem::MaybeUninit<crate::wire::Connector>,
8075 _: (),
8076 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8077 ::fidl_next::munge! {
8078 let crate::wire::Connector {
8079
8080 token,
8081
8082 } = out_;
8083 }
8084
8085 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8086
8087 Ok(())
8088 }
8089 }
8090
8091 pub struct DirEntry<T0> {
8092 pub token: T0,
8093 }
8094
8095 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirEntry, ___E> for DirEntry<T0>
8096 where
8097 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8098 ___E: ::fidl_next::fuchsia::HandleEncoder,
8099 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8100 {
8101 #[inline]
8102 fn encode(
8103 self,
8104 encoder_: &mut ___E,
8105 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirEntry>,
8106 _: (),
8107 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8108 ::fidl_next::munge! {
8109 let crate::wire::DirEntry {
8110
8111 token,
8112
8113 } = out_;
8114 }
8115
8116 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8117
8118 Ok(())
8119 }
8120 }
8121
8122 pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
8123 pub id: T0,
8124
8125 pub receiver: T1,
8126 }
8127
8128 unsafe impl<___E, T0, T1>
8129 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorCreateRequest, ___E>
8130 for CapabilityStoreConnectorCreateRequest<T0, T1>
8131 where
8132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8133 ___E: ::fidl_next::fuchsia::HandleEncoder,
8134 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8135 T1: ::fidl_next::Encode<
8136 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
8137 ___E,
8138 >,
8139 {
8140 #[inline]
8141 fn encode(
8142 self,
8143 encoder_: &mut ___E,
8144 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorCreateRequest>,
8145 _: (),
8146 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8147 ::fidl_next::munge! {
8148 let crate::wire::CapabilityStoreConnectorCreateRequest {
8149
8150 id,
8151 receiver,
8152
8153 } = out_;
8154 }
8155
8156 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8157
8158 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
8159
8160 Ok(())
8161 }
8162 }
8163
8164 pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
8165 pub id: T0,
8166
8167 pub server_end: T1,
8168 }
8169
8170 unsafe impl<___E, T0, T1>
8171 ::fidl_next::Encode<crate::wire::CapabilityStoreConnectorOpenRequest, ___E>
8172 for CapabilityStoreConnectorOpenRequest<T0, T1>
8173 where
8174 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8175 ___E: ::fidl_next::fuchsia::HandleEncoder,
8176 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8177 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8178 {
8179 #[inline]
8180 fn encode(
8181 self,
8182 encoder_: &mut ___E,
8183 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreConnectorOpenRequest>,
8184 _: (),
8185 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8186 ::fidl_next::munge! {
8187 let crate::wire::CapabilityStoreConnectorOpenRequest {
8188
8189 id,
8190 server_end,
8191
8192 } = out_;
8193 }
8194
8195 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8196
8197 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
8198
8199 Ok(())
8200 }
8201 }
8202
8203 pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
8204 pub id: T0,
8205
8206 pub receiver: T1,
8207 }
8208
8209 unsafe impl<___E, T0, T1>
8210 ::fidl_next::Encode<crate::wire::CapabilityStoreDirConnectorCreateRequest, ___E>
8211 for CapabilityStoreDirConnectorCreateRequest<T0, T1>
8212 where
8213 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8214 ___E: ::fidl_next::fuchsia::HandleEncoder,
8215 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8216 T1: ::fidl_next::Encode<
8217 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
8218 ___E,
8219 >,
8220 {
8221 #[inline]
8222 fn encode(
8223 self,
8224 encoder_: &mut ___E,
8225 out_: &mut ::core::mem::MaybeUninit<
8226 crate::wire::CapabilityStoreDirConnectorCreateRequest,
8227 >,
8228 _: (),
8229 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8230 ::fidl_next::munge! {
8231 let crate::wire::CapabilityStoreDirConnectorCreateRequest {
8232
8233 id,
8234 receiver,
8235
8236 } = out_;
8237 }
8238
8239 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8240
8241 ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
8242
8243 Ok(())
8244 }
8245 }
8246
8247 pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
8248 pub id: T0,
8249
8250 pub client_end: T1,
8251 }
8252
8253 unsafe impl<___E, T0, T1>
8254 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyImportRequest, ___E>
8255 for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
8256 where
8257 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8258 ___E: ::fidl_next::fuchsia::HandleEncoder,
8259 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8260 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8261 {
8262 #[inline]
8263 fn encode(
8264 self,
8265 encoder_: &mut ___E,
8266 out_: &mut ::core::mem::MaybeUninit<
8267 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
8268 >,
8269 _: (),
8270 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8271 ::fidl_next::munge! {
8272 let crate::wire::CapabilityStoreDictionaryLegacyImportRequest {
8273
8274 id,
8275 client_end,
8276
8277 } = out_;
8278 }
8279
8280 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8281
8282 ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
8283
8284 Ok(())
8285 }
8286 }
8287
8288 pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
8289 pub id: T0,
8290
8291 pub server_end: T1,
8292 }
8293
8294 unsafe impl<___E, T0, T1>
8295 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryLegacyExportRequest, ___E>
8296 for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
8297 where
8298 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8299 ___E: ::fidl_next::fuchsia::HandleEncoder,
8300 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8301 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8302 {
8303 #[inline]
8304 fn encode(
8305 self,
8306 encoder_: &mut ___E,
8307 out_: &mut ::core::mem::MaybeUninit<
8308 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
8309 >,
8310 _: (),
8311 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8312 ::fidl_next::munge! {
8313 let crate::wire::CapabilityStoreDictionaryLegacyExportRequest {
8314
8315 id,
8316 server_end,
8317
8318 } = out_;
8319 }
8320
8321 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8322
8323 ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
8324
8325 Ok(())
8326 }
8327 }
8328
8329 pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
8330 pub id: T0,
8331
8332 pub iterator: T1,
8333 }
8334
8335 unsafe impl<___E, T0, T1>
8336 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryKeysRequest, ___E>
8337 for CapabilityStoreDictionaryKeysRequest<T0, T1>
8338 where
8339 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8340 ___E: ::fidl_next::fuchsia::HandleEncoder,
8341 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8342 T1: ::fidl_next::Encode<
8343 ::fidl_next::ServerEnd<
8344 crate::DictionaryKeysIterator,
8345 ::fidl_next::wire::fuchsia::Channel,
8346 >,
8347 ___E,
8348 >,
8349 {
8350 #[inline]
8351 fn encode(
8352 self,
8353 encoder_: &mut ___E,
8354 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryKeysRequest>,
8355 _: (),
8356 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8357 ::fidl_next::munge! {
8358 let crate::wire::CapabilityStoreDictionaryKeysRequest {
8359
8360 id,
8361 iterator,
8362
8363 } = out_;
8364 }
8365
8366 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8367
8368 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8369
8370 Ok(())
8371 }
8372 }
8373
8374 pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
8375 pub id: T0,
8376
8377 pub iterator: T1,
8378 }
8379
8380 unsafe impl<___E, T0, T1>
8381 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryEnumerateRequest, ___E>
8382 for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
8383 where
8384 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8385 ___E: ::fidl_next::fuchsia::HandleEncoder,
8386 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8387 T1: ::fidl_next::Encode<
8388 ::fidl_next::ServerEnd<
8389 crate::DictionaryEnumerateIterator,
8390 ::fidl_next::wire::fuchsia::Channel,
8391 >,
8392 ___E,
8393 >,
8394 {
8395 #[inline]
8396 fn encode(
8397 self,
8398 encoder_: &mut ___E,
8399 out_: &mut ::core::mem::MaybeUninit<
8400 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
8401 >,
8402 _: (),
8403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8404 ::fidl_next::munge! {
8405 let crate::wire::CapabilityStoreDictionaryEnumerateRequest {
8406
8407 id,
8408 iterator,
8409
8410 } = out_;
8411 }
8412
8413 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8414
8415 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8416
8417 Ok(())
8418 }
8419 }
8420
8421 pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
8422 pub id: T0,
8423
8424 pub iterator: T1,
8425 }
8426
8427 unsafe impl<___E, T0, T1>
8428 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryDrainRequest, ___E>
8429 for CapabilityStoreDictionaryDrainRequest<T0, T1>
8430 where
8431 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8432 ___E: ::fidl_next::fuchsia::HandleEncoder,
8433 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8434 T1: ::fidl_next::Encode<
8435 ::fidl_next::ServerEnd<
8436 crate::DictionaryDrainIterator,
8437 ::fidl_next::wire::fuchsia::OptionalChannel,
8438 >,
8439 ___E,
8440 >,
8441 {
8442 #[inline]
8443 fn encode(
8444 self,
8445 encoder_: &mut ___E,
8446 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryDrainRequest>,
8447 _: (),
8448 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8449 ::fidl_next::munge! {
8450 let crate::wire::CapabilityStoreDictionaryDrainRequest {
8451
8452 id,
8453 iterator,
8454
8455 } = out_;
8456 }
8457
8458 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8459
8460 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8461
8462 Ok(())
8463 }
8464 }
8465
8466 pub struct CapabilityStoreCreateServiceAggregateRequest<T0> {
8467 pub sources: T0,
8468 }
8469
8470 unsafe impl<___E, T0>
8471 ::fidl_next::Encode<
8472 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
8473 ___E,
8474 > for CapabilityStoreCreateServiceAggregateRequest<T0>
8475 where
8476 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8477 ___E: ::fidl_next::Encoder,
8478 ___E: ::fidl_next::fuchsia::HandleEncoder,
8479 T0: ::fidl_next::Encode<
8480 ::fidl_next::wire::Vector<'static, crate::wire::AggregateSource<'static>>,
8481 ___E,
8482 >,
8483 {
8484 #[inline]
8485 fn encode(
8486 self,
8487 encoder_: &mut ___E,
8488 out_: &mut ::core::mem::MaybeUninit<
8489 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
8490 >,
8491 _: (),
8492 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8493 ::fidl_next::munge! {
8494 let crate::wire::CapabilityStoreCreateServiceAggregateRequest {
8495
8496 sources,
8497
8498 } = out_;
8499 }
8500
8501 ::fidl_next::Encode::encode(self.sources, encoder_, sources, (4294967295, ()))?;
8502
8503 Ok(())
8504 }
8505 }
8506
8507 pub struct CapabilityStoreCreateServiceAggregateResponse<T0> {
8508 pub aggregate_dir_connector: T0,
8509 }
8510
8511 unsafe impl<___E, T0>
8512 ::fidl_next::Encode<crate::wire::CapabilityStoreCreateServiceAggregateResponse, ___E>
8513 for CapabilityStoreCreateServiceAggregateResponse<T0>
8514 where
8515 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8516 ___E: ::fidl_next::fuchsia::HandleEncoder,
8517 T0: ::fidl_next::Encode<crate::wire::DirConnector, ___E>,
8518 {
8519 #[inline]
8520 fn encode(
8521 self,
8522 encoder_: &mut ___E,
8523 out_: &mut ::core::mem::MaybeUninit<
8524 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
8525 >,
8526 _: (),
8527 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8528 ::fidl_next::munge! {
8529 let crate::wire::CapabilityStoreCreateServiceAggregateResponse {
8530
8531 aggregate_dir_connector,
8532
8533 } = out_;
8534 }
8535
8536 ::fidl_next::Encode::encode(
8537 self.aggregate_dir_connector,
8538 encoder_,
8539 aggregate_dir_connector,
8540 (),
8541 )?;
8542
8543 Ok(())
8544 }
8545 }
8546
8547 pub struct CapabilityStoreExportResponse<T0> {
8548 pub capability: T0,
8549 }
8550
8551 unsafe impl<___E, T0>
8552 ::fidl_next::Encode<crate::wire::CapabilityStoreExportResponse<'static>, ___E>
8553 for CapabilityStoreExportResponse<T0>
8554 where
8555 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8556 ___E: ::fidl_next::Encoder,
8557 ___E: ::fidl_next::fuchsia::HandleEncoder,
8558 T0: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
8559 {
8560 #[inline]
8561 fn encode(
8562 self,
8563 encoder_: &mut ___E,
8564 out_: &mut ::core::mem::MaybeUninit<
8565 crate::wire::CapabilityStoreExportResponse<'static>,
8566 >,
8567 _: (),
8568 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8569 ::fidl_next::munge! {
8570 let crate::wire::CapabilityStoreExportResponse {
8571
8572 capability,
8573
8574 } = out_;
8575 }
8576
8577 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
8578
8579 Ok(())
8580 }
8581 }
8582
8583 pub struct CapabilityStoreImportRequest<T0, T1> {
8584 pub id: T0,
8585
8586 pub capability: T1,
8587 }
8588
8589 unsafe impl<___E, T0, T1>
8590 ::fidl_next::Encode<crate::wire::CapabilityStoreImportRequest<'static>, ___E>
8591 for CapabilityStoreImportRequest<T0, T1>
8592 where
8593 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8594 ___E: ::fidl_next::Encoder,
8595 ___E: ::fidl_next::fuchsia::HandleEncoder,
8596 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8597 T1: ::fidl_next::Encode<crate::wire::Capability<'static>, ___E>,
8598 {
8599 #[inline]
8600 fn encode(
8601 self,
8602 encoder_: &mut ___E,
8603 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreImportRequest<'static>>,
8604 _: (),
8605 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8606 ::fidl_next::munge! {
8607 let crate::wire::CapabilityStoreImportRequest {
8608
8609 id,
8610 capability,
8611
8612 } = out_;
8613 }
8614
8615 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
8616
8617 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
8618
8619 Ok(())
8620 }
8621 }
8622
8623 pub struct InstanceToken<T0> {
8624 pub token: T0,
8625 }
8626
8627 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::InstanceToken, ___E> for InstanceToken<T0>
8628 where
8629 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8630 ___E: ::fidl_next::fuchsia::HandleEncoder,
8631 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8632 {
8633 #[inline]
8634 fn encode(
8635 self,
8636 encoder_: &mut ___E,
8637 out_: &mut ::core::mem::MaybeUninit<crate::wire::InstanceToken>,
8638 _: (),
8639 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8640 ::fidl_next::munge! {
8641 let crate::wire::InstanceToken {
8642
8643 token,
8644
8645 } = out_;
8646 }
8647
8648 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
8649
8650 Ok(())
8651 }
8652 }
8653
8654 pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
8655 pub items: T0,
8656
8657 pub end_id: T1,
8658 }
8659
8660 unsafe impl<___E, T0, T1>
8661 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextResponse<'static>, ___E>
8662 for DictionaryDrainIteratorGetNextResponse<T0, T1>
8663 where
8664 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8665 ___E: ::fidl_next::Encoder,
8666 ___E: ::fidl_next::fuchsia::HandleEncoder,
8667 T0: ::fidl_next::Encode<
8668 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryItem<'static>>,
8669 ___E,
8670 >,
8671 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8672 {
8673 #[inline]
8674 fn encode(
8675 self,
8676 encoder_: &mut ___E,
8677 out_: &mut ::core::mem::MaybeUninit<
8678 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
8679 >,
8680 _: (),
8681 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8682 ::fidl_next::munge! {
8683 let crate::wire::DictionaryDrainIteratorGetNextResponse {
8684
8685 items,
8686 end_id,
8687
8688 } = out_;
8689 }
8690
8691 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
8692
8693 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
8694
8695 Ok(())
8696 }
8697 }
8698
8699 pub struct DictionaryOptionalItem<T0, T1> {
8700 pub key: T0,
8701
8702 pub value: T1,
8703 }
8704
8705 unsafe impl<___E, T0, T1>
8706 ::fidl_next::Encode<crate::wire::DictionaryOptionalItem<'static>, ___E>
8707 for DictionaryOptionalItem<T0, T1>
8708 where
8709 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8710 ___E: ::fidl_next::Encoder,
8711 ___E: ::fidl_next::fuchsia::HandleEncoder,
8712 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8713 T1: ::fidl_next::Encode<
8714 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
8715 ___E,
8716 >,
8717 {
8718 #[inline]
8719 fn encode(
8720 self,
8721 encoder_: &mut ___E,
8722 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryOptionalItem<'static>>,
8723 _: (),
8724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8725 ::fidl_next::munge! {
8726 let crate::wire::DictionaryOptionalItem {
8727
8728 key,
8729 value,
8730
8731 } = out_;
8732 }
8733
8734 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
8735
8736 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
8737
8738 Ok(())
8739 }
8740 }
8741
8742 pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
8743 pub items: T0,
8744
8745 pub end_id: T1,
8746 }
8747
8748 unsafe impl<___E, T0, T1>
8749 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>, ___E>
8750 for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
8751 where
8752 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8753 ___E: ::fidl_next::Encoder,
8754 ___E: ::fidl_next::fuchsia::HandleEncoder,
8755 T0: ::fidl_next::Encode<
8756 ::fidl_next::wire::Vector<'static, crate::wire::DictionaryOptionalItem<'static>>,
8757 ___E,
8758 >,
8759 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
8760 {
8761 #[inline]
8762 fn encode(
8763 self,
8764 encoder_: &mut ___E,
8765 out_: &mut ::core::mem::MaybeUninit<
8766 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
8767 >,
8768 _: (),
8769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8770 ::fidl_next::munge! {
8771 let crate::wire::DictionaryEnumerateIteratorGetNextResponse {
8772
8773 items,
8774 end_id,
8775
8776 } = out_;
8777 }
8778
8779 ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
8780
8781 ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
8782
8783 Ok(())
8784 }
8785 }
8786
8787 pub struct DictionaryKeysIteratorGetNextResponse<T0> {
8788 pub keys: T0,
8789 }
8790
8791 unsafe impl<___E, T0>
8792 ::fidl_next::Encode<crate::wire::DictionaryKeysIteratorGetNextResponse<'static>, ___E>
8793 for DictionaryKeysIteratorGetNextResponse<T0>
8794 where
8795 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8796 ___E: ::fidl_next::Encoder,
8797 ___E: ::fidl_next::fuchsia::HandleEncoder,
8798 T0: ::fidl_next::Encode<
8799 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
8800 ___E,
8801 >,
8802 {
8803 #[inline]
8804 fn encode(
8805 self,
8806 encoder_: &mut ___E,
8807 out_: &mut ::core::mem::MaybeUninit<
8808 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
8809 >,
8810 _: (),
8811 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8812 ::fidl_next::munge! {
8813 let crate::wire::DictionaryKeysIteratorGetNextResponse {
8814
8815 keys,
8816
8817 } = out_;
8818 }
8819
8820 ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
8821
8822 Ok(())
8823 }
8824 }
8825
8826 pub struct ProtocolPayload<T0> {
8827 pub channel: T0,
8828 }
8829
8830 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ProtocolPayload, ___E>
8831 for ProtocolPayload<T0>
8832 where
8833 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8834 ___E: ::fidl_next::fuchsia::HandleEncoder,
8835 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
8836 {
8837 #[inline]
8838 fn encode(
8839 self,
8840 encoder_: &mut ___E,
8841 out_: &mut ::core::mem::MaybeUninit<crate::wire::ProtocolPayload>,
8842 _: (),
8843 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8844 ::fidl_next::munge! {
8845 let crate::wire::ProtocolPayload {
8846
8847 channel,
8848
8849 } = out_;
8850 }
8851
8852 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
8853
8854 Ok(())
8855 }
8856 }
8857}
8858
8859pub use self::natural::*;
8860
8861#[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"]
8863#[derive(PartialEq, Debug)]
8864pub struct CapabilityStore;
8865
8866impl ::fidl_next::Discoverable for CapabilityStore {
8867 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
8868}
8869
8870#[cfg(target_os = "fuchsia")]
8871impl ::fidl_next::HasTransport for CapabilityStore {
8872 type Transport = ::fidl_next::fuchsia::zx::Channel;
8873}
8874
8875pub mod capability_store {
8876 pub mod prelude {
8877 pub use crate::{
8878 CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
8879 capability_store,
8880 };
8881
8882 pub use crate::natural::CapabilityStoreConnectorCreateRequest;
8883
8884 pub use crate::natural::CapabilityStoreConnectorOpenRequest;
8885
8886 pub use crate::natural::CapabilityStoreCreateServiceAggregateRequest;
8887
8888 pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
8889
8890 pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
8891
8892 pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
8893
8894 pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
8895
8896 pub use crate::natural::CapabilityStoreDictionaryGetRequest;
8897
8898 pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
8899
8900 pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
8901
8902 pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
8903
8904 pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
8905
8906 pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
8907
8908 pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
8909
8910 pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
8911
8912 pub use crate::natural::CapabilityStoreDropRequest;
8913
8914 pub use crate::natural::CapabilityStoreDuplicateRequest;
8915
8916 pub use crate::natural::CapabilityStoreError;
8917
8918 pub use crate::natural::CapabilityStoreExportRequest;
8919
8920 pub use crate::natural::CapabilityStoreImportRequest;
8921
8922 pub use crate::natural::CapabilityStoreConnectorCreateResponse;
8923
8924 pub use crate::natural::CapabilityStoreConnectorOpenResponse;
8925
8926 pub use crate::natural::CapabilityStoreCreateServiceAggregateResponse;
8927
8928 pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
8929
8930 pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
8931
8932 pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
8933
8934 pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
8935
8936 pub use crate::natural::CapabilityStoreDictionaryGetResponse;
8937
8938 pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
8939
8940 pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
8941
8942 pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
8943
8944 pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
8945
8946 pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
8947
8948 pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
8949
8950 pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
8951
8952 pub use crate::natural::CapabilityStoreDropResponse;
8953
8954 pub use crate::natural::CapabilityStoreDuplicateResponse;
8955
8956 pub use crate::natural::CapabilityStoreExportResponse;
8957
8958 pub use crate::natural::CapabilityStoreImportResponse;
8959 }
8960
8961 pub struct Duplicate;
8962
8963 impl ::fidl_next::Method for Duplicate {
8964 const ORDINAL: u64 = 6727592627741008260;
8965 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8966 ::fidl_next::protocol::Flexibility::Flexible;
8967
8968 type Protocol = crate::CapabilityStore;
8969
8970 type Request = crate::wire::CapabilityStoreDuplicateRequest;
8971 }
8972
8973 impl ::fidl_next::TwoWayMethod for Duplicate {
8974 type Response = ::fidl_next::wire::FlexibleResult<
8975 'static,
8976 crate::wire::CapabilityStoreDuplicateResponse,
8977 crate::wire::CapabilityStoreError,
8978 >;
8979 }
8980
8981 impl<___R> ::fidl_next::Respond<___R> for Duplicate {
8982 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
8983
8984 fn respond(response: ___R) -> Self::Output {
8985 ::fidl_next::FlexibleResult::Ok(response)
8986 }
8987 }
8988
8989 impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
8990 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8991
8992 fn respond_err(response: ___R) -> Self::Output {
8993 ::fidl_next::FlexibleResult::Err(response)
8994 }
8995 }
8996
8997 pub struct Drop;
8998
8999 impl ::fidl_next::Method for Drop {
9000 const ORDINAL: u64 = 753328233834620249;
9001 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9002 ::fidl_next::protocol::Flexibility::Flexible;
9003
9004 type Protocol = crate::CapabilityStore;
9005
9006 type Request = crate::wire::CapabilityStoreDropRequest;
9007 }
9008
9009 impl ::fidl_next::TwoWayMethod for Drop {
9010 type Response = ::fidl_next::wire::FlexibleResult<
9011 'static,
9012 crate::wire::CapabilityStoreDropResponse,
9013 crate::wire::CapabilityStoreError,
9014 >;
9015 }
9016
9017 impl<___R> ::fidl_next::Respond<___R> for Drop {
9018 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9019
9020 fn respond(response: ___R) -> Self::Output {
9021 ::fidl_next::FlexibleResult::Ok(response)
9022 }
9023 }
9024
9025 impl<___R> ::fidl_next::RespondErr<___R> for Drop {
9026 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9027
9028 fn respond_err(response: ___R) -> Self::Output {
9029 ::fidl_next::FlexibleResult::Err(response)
9030 }
9031 }
9032
9033 pub struct Export;
9034
9035 impl ::fidl_next::Method for Export {
9036 const ORDINAL: u64 = 226159162093533951;
9037 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9038 ::fidl_next::protocol::Flexibility::Flexible;
9039
9040 type Protocol = crate::CapabilityStore;
9041
9042 type Request = crate::wire::CapabilityStoreExportRequest;
9043 }
9044
9045 impl ::fidl_next::TwoWayMethod for Export {
9046 type Response = ::fidl_next::wire::FlexibleResult<
9047 'static,
9048 crate::wire::CapabilityStoreExportResponse<'static>,
9049 crate::wire::CapabilityStoreError,
9050 >;
9051 }
9052
9053 impl<___R> ::fidl_next::Respond<___R> for Export {
9054 type Output = ::fidl_next::FlexibleResult<
9055 crate::generic::CapabilityStoreExportResponse<___R>,
9056 ::fidl_next::util::Never,
9057 >;
9058
9059 fn respond(response: ___R) -> Self::Output {
9060 ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
9061 capability: response,
9062 })
9063 }
9064 }
9065
9066 impl<___R> ::fidl_next::RespondErr<___R> for Export {
9067 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9068
9069 fn respond_err(response: ___R) -> Self::Output {
9070 ::fidl_next::FlexibleResult::Err(response)
9071 }
9072 }
9073
9074 pub struct Import;
9075
9076 impl ::fidl_next::Method for Import {
9077 const ORDINAL: u64 = 2276030276116435867;
9078 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9079 ::fidl_next::protocol::Flexibility::Flexible;
9080
9081 type Protocol = crate::CapabilityStore;
9082
9083 type Request = crate::wire::CapabilityStoreImportRequest<'static>;
9084 }
9085
9086 impl ::fidl_next::TwoWayMethod for Import {
9087 type Response = ::fidl_next::wire::FlexibleResult<
9088 'static,
9089 crate::wire::CapabilityStoreImportResponse,
9090 crate::wire::CapabilityStoreError,
9091 >;
9092 }
9093
9094 impl<___R> ::fidl_next::Respond<___R> for Import {
9095 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9096
9097 fn respond(response: ___R) -> Self::Output {
9098 ::fidl_next::FlexibleResult::Ok(response)
9099 }
9100 }
9101
9102 impl<___R> ::fidl_next::RespondErr<___R> for Import {
9103 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9104
9105 fn respond_err(response: ___R) -> Self::Output {
9106 ::fidl_next::FlexibleResult::Err(response)
9107 }
9108 }
9109
9110 pub struct ConnectorCreate;
9111
9112 impl ::fidl_next::Method for ConnectorCreate {
9113 const ORDINAL: u64 = 2979461408102095909;
9114 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9115 ::fidl_next::protocol::Flexibility::Flexible;
9116
9117 type Protocol = crate::CapabilityStore;
9118
9119 type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
9120 }
9121
9122 impl ::fidl_next::TwoWayMethod for ConnectorCreate {
9123 type Response = ::fidl_next::wire::FlexibleResult<
9124 'static,
9125 crate::wire::CapabilityStoreConnectorCreateResponse,
9126 crate::wire::CapabilityStoreError,
9127 >;
9128 }
9129
9130 impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
9131 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9132
9133 fn respond(response: ___R) -> Self::Output {
9134 ::fidl_next::FlexibleResult::Ok(response)
9135 }
9136 }
9137
9138 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
9139 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9140
9141 fn respond_err(response: ___R) -> Self::Output {
9142 ::fidl_next::FlexibleResult::Err(response)
9143 }
9144 }
9145
9146 pub struct ConnectorOpen;
9147
9148 impl ::fidl_next::Method for ConnectorOpen {
9149 const ORDINAL: u64 = 6016362336453278623;
9150 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9151 ::fidl_next::protocol::Flexibility::Flexible;
9152
9153 type Protocol = crate::CapabilityStore;
9154
9155 type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
9156 }
9157
9158 impl ::fidl_next::TwoWayMethod for ConnectorOpen {
9159 type Response = ::fidl_next::wire::FlexibleResult<
9160 'static,
9161 crate::wire::CapabilityStoreConnectorOpenResponse,
9162 crate::wire::CapabilityStoreError,
9163 >;
9164 }
9165
9166 impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
9167 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9168
9169 fn respond(response: ___R) -> Self::Output {
9170 ::fidl_next::FlexibleResult::Ok(response)
9171 }
9172 }
9173
9174 impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
9175 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9176
9177 fn respond_err(response: ___R) -> Self::Output {
9178 ::fidl_next::FlexibleResult::Err(response)
9179 }
9180 }
9181
9182 pub struct DirConnectorCreate;
9183
9184 impl ::fidl_next::Method for DirConnectorCreate {
9185 const ORDINAL: u64 = 1756747594275428795;
9186 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9187 ::fidl_next::protocol::Flexibility::Flexible;
9188
9189 type Protocol = crate::CapabilityStore;
9190
9191 type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
9192 }
9193
9194 impl ::fidl_next::TwoWayMethod for DirConnectorCreate {
9195 type Response = ::fidl_next::wire::FlexibleResult<
9196 'static,
9197 crate::wire::CapabilityStoreDirConnectorCreateResponse,
9198 crate::wire::CapabilityStoreError,
9199 >;
9200 }
9201
9202 impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
9203 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9204
9205 fn respond(response: ___R) -> Self::Output {
9206 ::fidl_next::FlexibleResult::Ok(response)
9207 }
9208 }
9209
9210 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
9211 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9212
9213 fn respond_err(response: ___R) -> Self::Output {
9214 ::fidl_next::FlexibleResult::Err(response)
9215 }
9216 }
9217
9218 pub struct DirConnectorOpen;
9219
9220 impl ::fidl_next::Method for DirConnectorOpen {
9221 const ORDINAL: u64 = 6219704004220369153;
9222 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9223 ::fidl_next::protocol::Flexibility::Flexible;
9224
9225 type Protocol = crate::CapabilityStore;
9226
9227 type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>;
9228 }
9229
9230 impl ::fidl_next::TwoWayMethod for DirConnectorOpen {
9231 type Response = ::fidl_next::wire::FlexibleResult<
9232 'static,
9233 crate::wire::CapabilityStoreDirConnectorOpenResponse,
9234 crate::wire::CapabilityStoreError,
9235 >;
9236 }
9237
9238 impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
9239 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9240
9241 fn respond(response: ___R) -> Self::Output {
9242 ::fidl_next::FlexibleResult::Ok(response)
9243 }
9244 }
9245
9246 impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
9247 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9248
9249 fn respond_err(response: ___R) -> Self::Output {
9250 ::fidl_next::FlexibleResult::Err(response)
9251 }
9252 }
9253
9254 pub struct DictionaryCreate;
9255
9256 impl ::fidl_next::Method for DictionaryCreate {
9257 const ORDINAL: u64 = 7608770958894948499;
9258 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9259 ::fidl_next::protocol::Flexibility::Flexible;
9260
9261 type Protocol = crate::CapabilityStore;
9262
9263 type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
9264 }
9265
9266 impl ::fidl_next::TwoWayMethod for DictionaryCreate {
9267 type Response = ::fidl_next::wire::FlexibleResult<
9268 'static,
9269 crate::wire::CapabilityStoreDictionaryCreateResponse,
9270 crate::wire::CapabilityStoreError,
9271 >;
9272 }
9273
9274 impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
9275 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9276
9277 fn respond(response: ___R) -> Self::Output {
9278 ::fidl_next::FlexibleResult::Ok(response)
9279 }
9280 }
9281
9282 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
9283 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9284
9285 fn respond_err(response: ___R) -> Self::Output {
9286 ::fidl_next::FlexibleResult::Err(response)
9287 }
9288 }
9289
9290 pub struct DictionaryLegacyImport;
9291
9292 impl ::fidl_next::Method for DictionaryLegacyImport {
9293 const ORDINAL: u64 = 8285893703432012383;
9294 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9295 ::fidl_next::protocol::Flexibility::Flexible;
9296
9297 type Protocol = crate::CapabilityStore;
9298
9299 type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
9300 }
9301
9302 impl ::fidl_next::TwoWayMethod for DictionaryLegacyImport {
9303 type Response = ::fidl_next::wire::FlexibleResult<
9304 'static,
9305 crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
9306 crate::wire::CapabilityStoreError,
9307 >;
9308 }
9309
9310 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
9311 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9312
9313 fn respond(response: ___R) -> Self::Output {
9314 ::fidl_next::FlexibleResult::Ok(response)
9315 }
9316 }
9317
9318 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
9319 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9320
9321 fn respond_err(response: ___R) -> Self::Output {
9322 ::fidl_next::FlexibleResult::Err(response)
9323 }
9324 }
9325
9326 pub struct DictionaryLegacyExport;
9327
9328 impl ::fidl_next::Method for DictionaryLegacyExport {
9329 const ORDINAL: u64 = 4647175832683306445;
9330 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9331 ::fidl_next::protocol::Flexibility::Flexible;
9332
9333 type Protocol = crate::CapabilityStore;
9334
9335 type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
9336 }
9337
9338 impl ::fidl_next::TwoWayMethod for DictionaryLegacyExport {
9339 type Response = ::fidl_next::wire::FlexibleResult<
9340 'static,
9341 crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
9342 crate::wire::CapabilityStoreError,
9343 >;
9344 }
9345
9346 impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
9347 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9348
9349 fn respond(response: ___R) -> Self::Output {
9350 ::fidl_next::FlexibleResult::Ok(response)
9351 }
9352 }
9353
9354 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
9355 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9356
9357 fn respond_err(response: ___R) -> Self::Output {
9358 ::fidl_next::FlexibleResult::Err(response)
9359 }
9360 }
9361
9362 pub struct DictionaryInsert;
9363
9364 impl ::fidl_next::Method for DictionaryInsert {
9365 const ORDINAL: u64 = 8575443262986538023;
9366 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9367 ::fidl_next::protocol::Flexibility::Flexible;
9368
9369 type Protocol = crate::CapabilityStore;
9370
9371 type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
9372 }
9373
9374 impl ::fidl_next::TwoWayMethod for DictionaryInsert {
9375 type Response = ::fidl_next::wire::FlexibleResult<
9376 'static,
9377 crate::wire::CapabilityStoreDictionaryInsertResponse,
9378 crate::wire::CapabilityStoreError,
9379 >;
9380 }
9381
9382 impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
9383 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9384
9385 fn respond(response: ___R) -> Self::Output {
9386 ::fidl_next::FlexibleResult::Ok(response)
9387 }
9388 }
9389
9390 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
9391 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9392
9393 fn respond_err(response: ___R) -> Self::Output {
9394 ::fidl_next::FlexibleResult::Err(response)
9395 }
9396 }
9397
9398 pub struct DictionaryGet;
9399
9400 impl ::fidl_next::Method for DictionaryGet {
9401 const ORDINAL: u64 = 5592951026866236882;
9402 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9403 ::fidl_next::protocol::Flexibility::Flexible;
9404
9405 type Protocol = crate::CapabilityStore;
9406
9407 type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
9408 }
9409
9410 impl ::fidl_next::TwoWayMethod for DictionaryGet {
9411 type Response = ::fidl_next::wire::FlexibleResult<
9412 'static,
9413 crate::wire::CapabilityStoreDictionaryGetResponse,
9414 crate::wire::CapabilityStoreError,
9415 >;
9416 }
9417
9418 impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
9419 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9420
9421 fn respond(response: ___R) -> Self::Output {
9422 ::fidl_next::FlexibleResult::Ok(response)
9423 }
9424 }
9425
9426 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
9427 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9428
9429 fn respond_err(response: ___R) -> Self::Output {
9430 ::fidl_next::FlexibleResult::Err(response)
9431 }
9432 }
9433
9434 pub struct DictionaryRemove;
9435
9436 impl ::fidl_next::Method for DictionaryRemove {
9437 const ORDINAL: u64 = 343892214579320051;
9438 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9439 ::fidl_next::protocol::Flexibility::Flexible;
9440
9441 type Protocol = crate::CapabilityStore;
9442
9443 type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
9444 }
9445
9446 impl ::fidl_next::TwoWayMethod for DictionaryRemove {
9447 type Response = ::fidl_next::wire::FlexibleResult<
9448 'static,
9449 crate::wire::CapabilityStoreDictionaryRemoveResponse,
9450 crate::wire::CapabilityStoreError,
9451 >;
9452 }
9453
9454 impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
9455 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9456
9457 fn respond(response: ___R) -> Self::Output {
9458 ::fidl_next::FlexibleResult::Ok(response)
9459 }
9460 }
9461
9462 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
9463 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9464
9465 fn respond_err(response: ___R) -> Self::Output {
9466 ::fidl_next::FlexibleResult::Err(response)
9467 }
9468 }
9469
9470 pub struct DictionaryCopy;
9471
9472 impl ::fidl_next::Method for DictionaryCopy {
9473 const ORDINAL: u64 = 3977783339739362383;
9474 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9475 ::fidl_next::protocol::Flexibility::Flexible;
9476
9477 type Protocol = crate::CapabilityStore;
9478
9479 type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
9480 }
9481
9482 impl ::fidl_next::TwoWayMethod for DictionaryCopy {
9483 type Response = ::fidl_next::wire::FlexibleResult<
9484 'static,
9485 crate::wire::CapabilityStoreDictionaryCopyResponse,
9486 crate::wire::CapabilityStoreError,
9487 >;
9488 }
9489
9490 impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
9491 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9492
9493 fn respond(response: ___R) -> Self::Output {
9494 ::fidl_next::FlexibleResult::Ok(response)
9495 }
9496 }
9497
9498 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
9499 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9500
9501 fn respond_err(response: ___R) -> Self::Output {
9502 ::fidl_next::FlexibleResult::Err(response)
9503 }
9504 }
9505
9506 pub struct DictionaryKeys;
9507
9508 impl ::fidl_next::Method for DictionaryKeys {
9509 const ORDINAL: u64 = 597577248872787102;
9510 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9511 ::fidl_next::protocol::Flexibility::Flexible;
9512
9513 type Protocol = crate::CapabilityStore;
9514
9515 type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
9516 }
9517
9518 impl ::fidl_next::TwoWayMethod for DictionaryKeys {
9519 type Response = ::fidl_next::wire::FlexibleResult<
9520 'static,
9521 crate::wire::CapabilityStoreDictionaryKeysResponse,
9522 crate::wire::CapabilityStoreError,
9523 >;
9524 }
9525
9526 impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
9527 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9528
9529 fn respond(response: ___R) -> Self::Output {
9530 ::fidl_next::FlexibleResult::Ok(response)
9531 }
9532 }
9533
9534 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
9535 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9536
9537 fn respond_err(response: ___R) -> Self::Output {
9538 ::fidl_next::FlexibleResult::Err(response)
9539 }
9540 }
9541
9542 pub struct DictionaryEnumerate;
9543
9544 impl ::fidl_next::Method for DictionaryEnumerate {
9545 const ORDINAL: u64 = 964467096271472193;
9546 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9547 ::fidl_next::protocol::Flexibility::Flexible;
9548
9549 type Protocol = crate::CapabilityStore;
9550
9551 type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
9552 }
9553
9554 impl ::fidl_next::TwoWayMethod for DictionaryEnumerate {
9555 type Response = ::fidl_next::wire::FlexibleResult<
9556 'static,
9557 crate::wire::CapabilityStoreDictionaryEnumerateResponse,
9558 crate::wire::CapabilityStoreError,
9559 >;
9560 }
9561
9562 impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
9563 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9564
9565 fn respond(response: ___R) -> Self::Output {
9566 ::fidl_next::FlexibleResult::Ok(response)
9567 }
9568 }
9569
9570 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
9571 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9572
9573 fn respond_err(response: ___R) -> Self::Output {
9574 ::fidl_next::FlexibleResult::Err(response)
9575 }
9576 }
9577
9578 pub struct DictionaryDrain;
9579
9580 impl ::fidl_next::Method for DictionaryDrain {
9581 const ORDINAL: u64 = 2928364469569621208;
9582 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9583 ::fidl_next::protocol::Flexibility::Flexible;
9584
9585 type Protocol = crate::CapabilityStore;
9586
9587 type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
9588 }
9589
9590 impl ::fidl_next::TwoWayMethod for DictionaryDrain {
9591 type Response = ::fidl_next::wire::FlexibleResult<
9592 'static,
9593 crate::wire::CapabilityStoreDictionaryDrainResponse,
9594 crate::wire::CapabilityStoreError,
9595 >;
9596 }
9597
9598 impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
9599 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
9600
9601 fn respond(response: ___R) -> Self::Output {
9602 ::fidl_next::FlexibleResult::Ok(response)
9603 }
9604 }
9605
9606 impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
9607 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9608
9609 fn respond_err(response: ___R) -> Self::Output {
9610 ::fidl_next::FlexibleResult::Err(response)
9611 }
9612 }
9613
9614 pub struct CreateServiceAggregate;
9615
9616 impl ::fidl_next::Method for CreateServiceAggregate {
9617 const ORDINAL: u64 = 5009147843253209178;
9618 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9619 ::fidl_next::protocol::Flexibility::Flexible;
9620
9621 type Protocol = crate::CapabilityStore;
9622
9623 type Request = crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>;
9624 }
9625
9626 impl ::fidl_next::TwoWayMethod for CreateServiceAggregate {
9627 type Response = ::fidl_next::wire::FlexibleResult<
9628 'static,
9629 crate::wire::CapabilityStoreCreateServiceAggregateResponse,
9630 crate::wire::CapabilityStoreError,
9631 >;
9632 }
9633
9634 impl<___R> ::fidl_next::Respond<___R> for CreateServiceAggregate {
9635 type Output = ::fidl_next::FlexibleResult<
9636 crate::generic::CapabilityStoreCreateServiceAggregateResponse<___R>,
9637 ::fidl_next::util::Never,
9638 >;
9639
9640 fn respond(response: ___R) -> Self::Output {
9641 ::fidl_next::FlexibleResult::Ok(
9642 crate::generic::CapabilityStoreCreateServiceAggregateResponse {
9643 aggregate_dir_connector: response,
9644 },
9645 )
9646 }
9647 }
9648
9649 impl<___R> ::fidl_next::RespondErr<___R> for CreateServiceAggregate {
9650 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9651
9652 fn respond_err(response: ___R) -> Self::Output {
9653 ::fidl_next::FlexibleResult::Err(response)
9654 }
9655 }
9656
9657 mod ___detail {
9658 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
9659 where
9660 ___T: ::fidl_next::Transport,
9661 {
9662 type Client = CapabilityStoreClient<___T>;
9663 type Server = CapabilityStoreServer<___T>;
9664 }
9665
9666 #[repr(transparent)]
9668 pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
9669 #[allow(dead_code)]
9670 client: ::fidl_next::protocol::Client<___T>,
9671 }
9672
9673 impl<___T> CapabilityStoreClient<___T>
9674 where
9675 ___T: ::fidl_next::Transport,
9676 {
9677 #[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"]
9678 pub fn duplicate(
9679 &self,
9680
9681 id: impl ::fidl_next::Encode<
9682 ::fidl_next::wire::Uint64,
9683 <___T as ::fidl_next::Transport>::SendBuffer,
9684 >,
9685
9686 dest_id: impl ::fidl_next::Encode<
9687 ::fidl_next::wire::Uint64,
9688 <___T as ::fidl_next::Transport>::SendBuffer,
9689 >,
9690 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
9691 where
9692 <___T as ::fidl_next::Transport>::SendBuffer:
9693 ::fidl_next::encoder::InternalHandleEncoder,
9694 {
9695 self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
9696 }
9697
9698 #[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"]
9699 pub fn duplicate_with<___R>(
9700 &self,
9701 request: ___R,
9702 ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
9703 where
9704 ___R: ::fidl_next::Encode<
9705 crate::wire::CapabilityStoreDuplicateRequest,
9706 <___T as ::fidl_next::Transport>::SendBuffer,
9707 >,
9708 {
9709 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9710 6727592627741008260,
9711 <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
9712 request,
9713 ))
9714 }
9715
9716 #[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"]
9717 pub fn drop(
9718 &self,
9719
9720 id: impl ::fidl_next::Encode<
9721 ::fidl_next::wire::Uint64,
9722 <___T as ::fidl_next::Transport>::SendBuffer,
9723 >,
9724 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
9725 where
9726 <___T as ::fidl_next::Transport>::SendBuffer:
9727 ::fidl_next::encoder::InternalHandleEncoder,
9728 {
9729 self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
9730 }
9731
9732 #[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"]
9733 pub fn drop_with<___R>(
9734 &self,
9735 request: ___R,
9736 ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
9737 where
9738 ___R: ::fidl_next::Encode<
9739 crate::wire::CapabilityStoreDropRequest,
9740 <___T as ::fidl_next::Transport>::SendBuffer,
9741 >,
9742 {
9743 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9744 753328233834620249,
9745 <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
9746 request,
9747 ))
9748 }
9749
9750 #[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"]
9751 pub fn export(
9752 &self,
9753
9754 id: impl ::fidl_next::Encode<
9755 ::fidl_next::wire::Uint64,
9756 <___T as ::fidl_next::Transport>::SendBuffer,
9757 >,
9758 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
9759 where
9760 <___T as ::fidl_next::Transport>::SendBuffer:
9761 ::fidl_next::encoder::InternalHandleEncoder,
9762 {
9763 self.export_with(crate::generic::CapabilityStoreExportRequest { id })
9764 }
9765
9766 #[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"]
9767 pub fn export_with<___R>(
9768 &self,
9769 request: ___R,
9770 ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
9771 where
9772 ___R: ::fidl_next::Encode<
9773 crate::wire::CapabilityStoreExportRequest,
9774 <___T as ::fidl_next::Transport>::SendBuffer,
9775 >,
9776 {
9777 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9778 226159162093533951,
9779 <super::Export as ::fidl_next::Method>::FLEXIBILITY,
9780 request,
9781 ))
9782 }
9783
9784 #[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"]
9785 pub fn import(
9786 &self,
9787
9788 id: impl ::fidl_next::Encode<
9789 ::fidl_next::wire::Uint64,
9790 <___T as ::fidl_next::Transport>::SendBuffer,
9791 >,
9792
9793 capability: impl ::fidl_next::Encode<
9794 crate::wire::Capability<'static>,
9795 <___T as ::fidl_next::Transport>::SendBuffer,
9796 >,
9797 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
9798 where
9799 <___T as ::fidl_next::Transport>::SendBuffer:
9800 ::fidl_next::encoder::InternalHandleEncoder,
9801 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9802 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9803 {
9804 self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
9805 }
9806
9807 #[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"]
9808 pub fn import_with<___R>(
9809 &self,
9810 request: ___R,
9811 ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
9812 where
9813 ___R: ::fidl_next::Encode<
9814 crate::wire::CapabilityStoreImportRequest<'static>,
9815 <___T as ::fidl_next::Transport>::SendBuffer,
9816 >,
9817 {
9818 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9819 2276030276116435867,
9820 <super::Import as ::fidl_next::Method>::FLEXIBILITY,
9821 request,
9822 ))
9823 }
9824
9825 #[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"]
9826 pub fn connector_create(
9827 &self,
9828
9829 id: impl ::fidl_next::Encode<
9830 ::fidl_next::wire::Uint64,
9831 <___T as ::fidl_next::Transport>::SendBuffer,
9832 >,
9833
9834 receiver: impl ::fidl_next::Encode<
9835 ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::wire::fuchsia::Channel>,
9836 <___T as ::fidl_next::Transport>::SendBuffer,
9837 >,
9838 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
9839 where
9840 <___T as ::fidl_next::Transport>::SendBuffer:
9841 ::fidl_next::encoder::InternalHandleEncoder,
9842 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9843 {
9844 self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
9845 id,
9846
9847 receiver,
9848 })
9849 }
9850
9851 #[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"]
9852 pub fn connector_create_with<___R>(
9853 &self,
9854 request: ___R,
9855 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
9856 where
9857 ___R: ::fidl_next::Encode<
9858 crate::wire::CapabilityStoreConnectorCreateRequest,
9859 <___T as ::fidl_next::Transport>::SendBuffer,
9860 >,
9861 {
9862 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9863 2979461408102095909,
9864 <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
9865 request,
9866 ))
9867 }
9868
9869 #[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"]
9870 pub fn connector_open(
9871 &self,
9872
9873 id: impl ::fidl_next::Encode<
9874 ::fidl_next::wire::Uint64,
9875 <___T as ::fidl_next::Transport>::SendBuffer,
9876 >,
9877
9878 server_end: impl ::fidl_next::Encode<
9879 ::fidl_next::wire::fuchsia::Channel,
9880 <___T as ::fidl_next::Transport>::SendBuffer,
9881 >,
9882 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
9883 where
9884 <___T as ::fidl_next::Transport>::SendBuffer:
9885 ::fidl_next::encoder::InternalHandleEncoder,
9886 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9887 {
9888 self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
9889 id,
9890
9891 server_end,
9892 })
9893 }
9894
9895 #[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"]
9896 pub fn connector_open_with<___R>(
9897 &self,
9898 request: ___R,
9899 ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
9900 where
9901 ___R: ::fidl_next::Encode<
9902 crate::wire::CapabilityStoreConnectorOpenRequest,
9903 <___T as ::fidl_next::Transport>::SendBuffer,
9904 >,
9905 {
9906 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9907 6016362336453278623,
9908 <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
9909 request,
9910 ))
9911 }
9912
9913 #[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"]
9914 pub fn dir_connector_create(
9915 &self,
9916
9917 id: impl ::fidl_next::Encode<
9918 ::fidl_next::wire::Uint64,
9919 <___T as ::fidl_next::Transport>::SendBuffer,
9920 >,
9921
9922 receiver: impl ::fidl_next::Encode<
9923 ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::wire::fuchsia::Channel>,
9924 <___T as ::fidl_next::Transport>::SendBuffer,
9925 >,
9926 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
9927 where
9928 <___T as ::fidl_next::Transport>::SendBuffer:
9929 ::fidl_next::encoder::InternalHandleEncoder,
9930 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9931 {
9932 self.dir_connector_create_with(
9933 crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
9934 )
9935 }
9936
9937 #[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"]
9938 pub fn dir_connector_create_with<___R>(
9939 &self,
9940 request: ___R,
9941 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
9942 where
9943 ___R: ::fidl_next::Encode<
9944 crate::wire::CapabilityStoreDirConnectorCreateRequest,
9945 <___T as ::fidl_next::Transport>::SendBuffer,
9946 >,
9947 {
9948 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9949 1756747594275428795,
9950 <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
9951 request,
9952 ))
9953 }
9954
9955 #[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"]
9956 pub fn dir_connector_open_with<___R>(
9957 &self,
9958 request: ___R,
9959 ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
9960 where
9961 ___R: ::fidl_next::Encode<
9962 crate::wire::CapabilityStoreDirConnectorOpenRequest<'static>,
9963 <___T as ::fidl_next::Transport>::SendBuffer,
9964 >,
9965 {
9966 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9967 6219704004220369153,
9968 <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
9969 request,
9970 ))
9971 }
9972
9973 #[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"]
9974 pub fn dictionary_create(
9975 &self,
9976
9977 id: impl ::fidl_next::Encode<
9978 ::fidl_next::wire::Uint64,
9979 <___T as ::fidl_next::Transport>::SendBuffer,
9980 >,
9981 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
9982 where
9983 <___T as ::fidl_next::Transport>::SendBuffer:
9984 ::fidl_next::encoder::InternalHandleEncoder,
9985 {
9986 self.dictionary_create_with(
9987 crate::generic::CapabilityStoreDictionaryCreateRequest { id },
9988 )
9989 }
9990
9991 #[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"]
9992 pub fn dictionary_create_with<___R>(
9993 &self,
9994 request: ___R,
9995 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
9996 where
9997 ___R: ::fidl_next::Encode<
9998 crate::wire::CapabilityStoreDictionaryCreateRequest,
9999 <___T as ::fidl_next::Transport>::SendBuffer,
10000 >,
10001 {
10002 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10003 7608770958894948499,
10004 <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
10005 request,
10006 ))
10007 }
10008
10009 #[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"]
10010 pub fn dictionary_legacy_import(
10011 &self,
10012
10013 id: impl ::fidl_next::Encode<
10014 ::fidl_next::wire::Uint64,
10015 <___T as ::fidl_next::Transport>::SendBuffer,
10016 >,
10017
10018 client_end: impl ::fidl_next::Encode<
10019 ::fidl_next::wire::fuchsia::Channel,
10020 <___T as ::fidl_next::Transport>::SendBuffer,
10021 >,
10022 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
10023 where
10024 <___T as ::fidl_next::Transport>::SendBuffer:
10025 ::fidl_next::encoder::InternalHandleEncoder,
10026 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10027 {
10028 self.dictionary_legacy_import_with(
10029 crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
10030 )
10031 }
10032
10033 #[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"]
10034 pub fn dictionary_legacy_import_with<___R>(
10035 &self,
10036 request: ___R,
10037 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
10038 where
10039 ___R: ::fidl_next::Encode<
10040 crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
10041 <___T as ::fidl_next::Transport>::SendBuffer,
10042 >,
10043 {
10044 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10045 8285893703432012383,
10046 <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
10047 request,
10048 ))
10049 }
10050
10051 #[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"]
10052 pub fn dictionary_legacy_export(
10053 &self,
10054
10055 id: impl ::fidl_next::Encode<
10056 ::fidl_next::wire::Uint64,
10057 <___T as ::fidl_next::Transport>::SendBuffer,
10058 >,
10059
10060 server_end: impl ::fidl_next::Encode<
10061 ::fidl_next::wire::fuchsia::Channel,
10062 <___T as ::fidl_next::Transport>::SendBuffer,
10063 >,
10064 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
10065 where
10066 <___T as ::fidl_next::Transport>::SendBuffer:
10067 ::fidl_next::encoder::InternalHandleEncoder,
10068 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10069 {
10070 self.dictionary_legacy_export_with(
10071 crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
10072 )
10073 }
10074
10075 #[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"]
10076 pub fn dictionary_legacy_export_with<___R>(
10077 &self,
10078 request: ___R,
10079 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
10080 where
10081 ___R: ::fidl_next::Encode<
10082 crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
10083 <___T as ::fidl_next::Transport>::SendBuffer,
10084 >,
10085 {
10086 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10087 4647175832683306445,
10088 <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
10089 request,
10090 ))
10091 }
10092
10093 #[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"]
10094 pub fn dictionary_insert(
10095 &self,
10096
10097 id: impl ::fidl_next::Encode<
10098 ::fidl_next::wire::Uint64,
10099 <___T as ::fidl_next::Transport>::SendBuffer,
10100 >,
10101
10102 item: impl ::fidl_next::Encode<
10103 crate::wire::DictionaryItem<'static>,
10104 <___T as ::fidl_next::Transport>::SendBuffer,
10105 >,
10106 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
10107 where
10108 <___T as ::fidl_next::Transport>::SendBuffer:
10109 ::fidl_next::encoder::InternalHandleEncoder,
10110 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10111 {
10112 self.dictionary_insert_with(
10113 crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
10114 )
10115 }
10116
10117 #[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"]
10118 pub fn dictionary_insert_with<___R>(
10119 &self,
10120 request: ___R,
10121 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
10122 where
10123 ___R: ::fidl_next::Encode<
10124 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
10125 <___T as ::fidl_next::Transport>::SendBuffer,
10126 >,
10127 {
10128 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10129 8575443262986538023,
10130 <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
10131 request,
10132 ))
10133 }
10134
10135 #[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"]
10136 pub fn dictionary_get(
10137 &self,
10138
10139 id: impl ::fidl_next::Encode<
10140 ::fidl_next::wire::Uint64,
10141 <___T as ::fidl_next::Transport>::SendBuffer,
10142 >,
10143
10144 key: impl ::fidl_next::Encode<
10145 ::fidl_next::wire::String<'static>,
10146 <___T as ::fidl_next::Transport>::SendBuffer,
10147 >,
10148
10149 dest_id: impl ::fidl_next::Encode<
10150 ::fidl_next::wire::Uint64,
10151 <___T as ::fidl_next::Transport>::SendBuffer,
10152 >,
10153 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
10154 where
10155 <___T as ::fidl_next::Transport>::SendBuffer:
10156 ::fidl_next::encoder::InternalHandleEncoder,
10157 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10158 {
10159 self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
10160 id,
10161
10162 key,
10163
10164 dest_id,
10165 })
10166 }
10167
10168 #[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"]
10169 pub fn dictionary_get_with<___R>(
10170 &self,
10171 request: ___R,
10172 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
10173 where
10174 ___R: ::fidl_next::Encode<
10175 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
10176 <___T as ::fidl_next::Transport>::SendBuffer,
10177 >,
10178 {
10179 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10180 5592951026866236882,
10181 <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
10182 request,
10183 ))
10184 }
10185
10186 #[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"]
10187 pub fn dictionary_remove(
10188 &self,
10189
10190 id: impl ::fidl_next::Encode<
10191 ::fidl_next::wire::Uint64,
10192 <___T as ::fidl_next::Transport>::SendBuffer,
10193 >,
10194
10195 key: impl ::fidl_next::Encode<
10196 ::fidl_next::wire::String<'static>,
10197 <___T as ::fidl_next::Transport>::SendBuffer,
10198 >,
10199
10200 dest_id: impl ::fidl_next::Encode<
10201 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
10202 <___T as ::fidl_next::Transport>::SendBuffer,
10203 >,
10204 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
10205 where
10206 <___T as ::fidl_next::Transport>::SendBuffer:
10207 ::fidl_next::encoder::InternalHandleEncoder,
10208 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10209 {
10210 self.dictionary_remove_with(
10211 crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
10212 )
10213 }
10214
10215 #[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"]
10216 pub fn dictionary_remove_with<___R>(
10217 &self,
10218 request: ___R,
10219 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
10220 where
10221 ___R: ::fidl_next::Encode<
10222 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
10223 <___T as ::fidl_next::Transport>::SendBuffer,
10224 >,
10225 {
10226 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10227 343892214579320051,
10228 <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
10229 request,
10230 ))
10231 }
10232
10233 #[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"]
10234 pub fn dictionary_copy(
10235 &self,
10236
10237 id: impl ::fidl_next::Encode<
10238 ::fidl_next::wire::Uint64,
10239 <___T as ::fidl_next::Transport>::SendBuffer,
10240 >,
10241
10242 dest_id: impl ::fidl_next::Encode<
10243 ::fidl_next::wire::Uint64,
10244 <___T as ::fidl_next::Transport>::SendBuffer,
10245 >,
10246 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
10247 where
10248 <___T as ::fidl_next::Transport>::SendBuffer:
10249 ::fidl_next::encoder::InternalHandleEncoder,
10250 {
10251 self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
10252 id,
10253
10254 dest_id,
10255 })
10256 }
10257
10258 #[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"]
10259 pub fn dictionary_copy_with<___R>(
10260 &self,
10261 request: ___R,
10262 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
10263 where
10264 ___R: ::fidl_next::Encode<
10265 crate::wire::CapabilityStoreDictionaryCopyRequest,
10266 <___T as ::fidl_next::Transport>::SendBuffer,
10267 >,
10268 {
10269 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10270 3977783339739362383,
10271 <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
10272 request,
10273 ))
10274 }
10275
10276 #[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"]
10277 pub fn dictionary_keys(
10278 &self,
10279
10280 id: impl ::fidl_next::Encode<
10281 ::fidl_next::wire::Uint64,
10282 <___T as ::fidl_next::Transport>::SendBuffer,
10283 >,
10284
10285 iterator: impl ::fidl_next::Encode<
10286 ::fidl_next::ServerEnd<
10287 crate::DictionaryKeysIterator,
10288 ::fidl_next::wire::fuchsia::Channel,
10289 >,
10290 <___T as ::fidl_next::Transport>::SendBuffer,
10291 >,
10292 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
10293 where
10294 <___T as ::fidl_next::Transport>::SendBuffer:
10295 ::fidl_next::encoder::InternalHandleEncoder,
10296 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10297 {
10298 self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
10299 id,
10300
10301 iterator,
10302 })
10303 }
10304
10305 #[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"]
10306 pub fn dictionary_keys_with<___R>(
10307 &self,
10308 request: ___R,
10309 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
10310 where
10311 ___R: ::fidl_next::Encode<
10312 crate::wire::CapabilityStoreDictionaryKeysRequest,
10313 <___T as ::fidl_next::Transport>::SendBuffer,
10314 >,
10315 {
10316 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10317 597577248872787102,
10318 <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
10319 request,
10320 ))
10321 }
10322
10323 #[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"]
10324 pub fn dictionary_enumerate(
10325 &self,
10326
10327 id: impl ::fidl_next::Encode<
10328 ::fidl_next::wire::Uint64,
10329 <___T as ::fidl_next::Transport>::SendBuffer,
10330 >,
10331
10332 iterator: impl ::fidl_next::Encode<
10333 ::fidl_next::ServerEnd<
10334 crate::DictionaryEnumerateIterator,
10335 ::fidl_next::wire::fuchsia::Channel,
10336 >,
10337 <___T as ::fidl_next::Transport>::SendBuffer,
10338 >,
10339 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
10340 where
10341 <___T as ::fidl_next::Transport>::SendBuffer:
10342 ::fidl_next::encoder::InternalHandleEncoder,
10343 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10344 {
10345 self.dictionary_enumerate_with(
10346 crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
10347 )
10348 }
10349
10350 #[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"]
10351 pub fn dictionary_enumerate_with<___R>(
10352 &self,
10353 request: ___R,
10354 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
10355 where
10356 ___R: ::fidl_next::Encode<
10357 crate::wire::CapabilityStoreDictionaryEnumerateRequest,
10358 <___T as ::fidl_next::Transport>::SendBuffer,
10359 >,
10360 {
10361 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10362 964467096271472193,
10363 <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
10364 request,
10365 ))
10366 }
10367
10368 #[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"]
10369 pub fn dictionary_drain(
10370 &self,
10371
10372 id: impl ::fidl_next::Encode<
10373 ::fidl_next::wire::Uint64,
10374 <___T as ::fidl_next::Transport>::SendBuffer,
10375 >,
10376
10377 iterator: impl ::fidl_next::Encode<
10378 ::fidl_next::ServerEnd<
10379 crate::DictionaryDrainIterator,
10380 ::fidl_next::wire::fuchsia::OptionalChannel,
10381 >,
10382 <___T as ::fidl_next::Transport>::SendBuffer,
10383 >,
10384 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
10385 where
10386 <___T as ::fidl_next::Transport>::SendBuffer:
10387 ::fidl_next::encoder::InternalHandleEncoder,
10388 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10389 {
10390 self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
10391 id,
10392
10393 iterator,
10394 })
10395 }
10396
10397 #[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"]
10398 pub fn dictionary_drain_with<___R>(
10399 &self,
10400 request: ___R,
10401 ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
10402 where
10403 ___R: ::fidl_next::Encode<
10404 crate::wire::CapabilityStoreDictionaryDrainRequest,
10405 <___T as ::fidl_next::Transport>::SendBuffer,
10406 >,
10407 {
10408 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10409 2928364469569621208,
10410 <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
10411 request,
10412 ))
10413 }
10414
10415 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10416 pub fn create_service_aggregate(
10417 &self,
10418
10419 sources: impl ::fidl_next::Encode<
10420 ::fidl_next::wire::Vector<'static, crate::wire::AggregateSource<'static>>,
10421 <___T as ::fidl_next::Transport>::SendBuffer,
10422 >,
10423 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
10424 where
10425 <___T as ::fidl_next::Transport>::SendBuffer:
10426 ::fidl_next::encoder::InternalHandleEncoder,
10427 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10428 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10429 {
10430 self.create_service_aggregate_with(
10431 crate::generic::CapabilityStoreCreateServiceAggregateRequest { sources },
10432 )
10433 }
10434
10435 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10436 pub fn create_service_aggregate_with<___R>(
10437 &self,
10438 request: ___R,
10439 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateServiceAggregate, ___T>
10440 where
10441 ___R: ::fidl_next::Encode<
10442 crate::wire::CapabilityStoreCreateServiceAggregateRequest<'static>,
10443 <___T as ::fidl_next::Transport>::SendBuffer,
10444 >,
10445 {
10446 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10447 5009147843253209178,
10448 <super::CreateServiceAggregate as ::fidl_next::Method>::FLEXIBILITY,
10449 request,
10450 ))
10451 }
10452 }
10453
10454 #[repr(transparent)]
10456 pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
10457 server: ::fidl_next::protocol::Server<___T>,
10458 }
10459
10460 impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
10461 }
10462}
10463
10464pub trait CapabilityStoreClientHandler<
10468 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10469 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10470>
10471{
10472 fn on_unknown_interaction(
10473 &mut self,
10474 ordinal: u64,
10475 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10476 ::core::future::ready(())
10477 }
10478}
10479
10480impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
10481where
10482 ___T: ::fidl_next::Transport,
10483{
10484 async fn on_unknown_interaction(&mut self, _: u64) {}
10485}
10486
10487impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
10488where
10489 ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
10490 ___T: ::fidl_next::Transport,
10491{
10492 async fn on_event(
10493 handler: &mut ___H,
10494 ordinal: u64,
10495 flexibility: ::fidl_next::protocol::Flexibility,
10496 body: ::fidl_next::Body<___T>,
10497 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10498 match ordinal {
10499 ordinal => {
10500 handler.on_unknown_interaction(ordinal).await;
10501 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10502 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10503 } else {
10504 Ok(())
10505 }
10506 }
10507 }
10508 }
10509}
10510
10511pub trait CapabilityStoreServerHandler<
10515 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10516 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10517>
10518{
10519 #[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"]
10520 fn duplicate(
10521 &mut self,
10522
10523 request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
10524
10525 responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
10526 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10527
10528 #[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"]
10529 fn drop(
10530 &mut self,
10531
10532 request: ::fidl_next::Request<capability_store::Drop, ___T>,
10533
10534 responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
10535 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10536
10537 #[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"]
10538 fn export(
10539 &mut self,
10540
10541 request: ::fidl_next::Request<capability_store::Export, ___T>,
10542
10543 responder: ::fidl_next::Responder<capability_store::Export, ___T>,
10544 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10545
10546 #[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"]
10547 fn import(
10548 &mut self,
10549
10550 request: ::fidl_next::Request<capability_store::Import, ___T>,
10551
10552 responder: ::fidl_next::Responder<capability_store::Import, ___T>,
10553 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10554
10555 #[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"]
10556 fn connector_create(
10557 &mut self,
10558
10559 request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
10560
10561 responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
10562 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10563
10564 #[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"]
10565 fn connector_open(
10566 &mut self,
10567
10568 request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
10569
10570 responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
10571 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10572
10573 #[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"]
10574 fn dir_connector_create(
10575 &mut self,
10576
10577 request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
10578
10579 responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
10580 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10581
10582 #[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"]
10583 fn dir_connector_open(
10584 &mut self,
10585
10586 request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
10587
10588 responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
10589 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10590
10591 #[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"]
10592 fn dictionary_create(
10593 &mut self,
10594
10595 request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
10596
10597 responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
10598 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10599
10600 #[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"]
10601 fn dictionary_legacy_import(
10602 &mut self,
10603
10604 request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
10605
10606 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
10607 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10608
10609 #[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"]
10610 fn dictionary_legacy_export(
10611 &mut self,
10612
10613 request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
10614
10615 responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
10616 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10617
10618 #[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"]
10619 fn dictionary_insert(
10620 &mut self,
10621
10622 request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
10623
10624 responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
10625 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10626
10627 #[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"]
10628 fn dictionary_get(
10629 &mut self,
10630
10631 request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
10632
10633 responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
10634 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10635
10636 #[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"]
10637 fn dictionary_remove(
10638 &mut self,
10639
10640 request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
10641
10642 responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
10643 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10644
10645 #[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"]
10646 fn dictionary_copy(
10647 &mut self,
10648
10649 request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
10650
10651 responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
10652 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10653
10654 #[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"]
10655 fn dictionary_keys(
10656 &mut self,
10657
10658 request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
10659
10660 responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
10661 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10662
10663 #[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"]
10664 fn dictionary_enumerate(
10665 &mut self,
10666
10667 request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
10668
10669 responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
10670 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10671
10672 #[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"]
10673 fn dictionary_drain(
10674 &mut self,
10675
10676 request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
10677
10678 responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
10679 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10680
10681 #[doc = " Creates a new DirConnector that forwards open requests to a set of\n sources.\n"]
10682 fn create_service_aggregate(
10683 &mut self,
10684
10685 request: ::fidl_next::Request<capability_store::CreateServiceAggregate, ___T>,
10686
10687 responder: ::fidl_next::Responder<capability_store::CreateServiceAggregate, ___T>,
10688 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10689
10690 fn on_unknown_interaction(
10691 &mut self,
10692 ordinal: u64,
10693 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10694 ::core::future::ready(())
10695 }
10696}
10697
10698impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
10699where
10700 ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
10701 ___T: ::fidl_next::Transport,
10702 for<'de> crate::wire::CapabilityStoreDuplicateRequest: ::fidl_next::Decode<
10703 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10704 Constraint = (),
10705 >,
10706 for<'de> crate::wire::CapabilityStoreDropRequest: ::fidl_next::Decode<
10707 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10708 Constraint = (),
10709 >,
10710 for<'de> crate::wire::CapabilityStoreExportRequest: ::fidl_next::Decode<
10711 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10712 Constraint = (),
10713 >,
10714 for<'de> crate::wire::CapabilityStoreImportRequest<'de>: ::fidl_next::Decode<
10715 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10716 Constraint = (),
10717 >,
10718 for<'de> crate::wire::CapabilityStoreConnectorCreateRequest: ::fidl_next::Decode<
10719 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10720 Constraint = (),
10721 >,
10722 for<'de> crate::wire::CapabilityStoreConnectorOpenRequest: ::fidl_next::Decode<
10723 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10724 Constraint = (),
10725 >,
10726 for<'de> crate::wire::CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Decode<
10727 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10728 Constraint = (),
10729 >,
10730 for<'de> crate::wire::CapabilityStoreDirConnectorOpenRequest<'de>: ::fidl_next::Decode<
10731 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10732 Constraint = (),
10733 >,
10734 for<'de> crate::wire::CapabilityStoreDictionaryCreateRequest: ::fidl_next::Decode<
10735 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10736 Constraint = (),
10737 >,
10738 for<'de> crate::wire::CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Decode<
10739 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10740 Constraint = (),
10741 >,
10742 for<'de> crate::wire::CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Decode<
10743 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10744 Constraint = (),
10745 >,
10746 for<'de> crate::wire::CapabilityStoreDictionaryInsertRequest<'de>: ::fidl_next::Decode<
10747 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10748 Constraint = (),
10749 >,
10750 for<'de> crate::wire::CapabilityStoreDictionaryGetRequest<'de>: ::fidl_next::Decode<
10751 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10752 Constraint = (),
10753 >,
10754 for<'de> crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>: ::fidl_next::Decode<
10755 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10756 Constraint = (),
10757 >,
10758 for<'de> crate::wire::CapabilityStoreDictionaryCopyRequest: ::fidl_next::Decode<
10759 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10760 Constraint = (),
10761 >,
10762 for<'de> crate::wire::CapabilityStoreDictionaryKeysRequest: ::fidl_next::Decode<
10763 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10764 Constraint = (),
10765 >,
10766 for<'de> crate::wire::CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Decode<
10767 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10768 Constraint = (),
10769 >,
10770 for<'de> crate::wire::CapabilityStoreDictionaryDrainRequest: ::fidl_next::Decode<
10771 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10772 Constraint = (),
10773 >,
10774 for<'de> crate::wire::CapabilityStoreCreateServiceAggregateRequest<'de>: ::fidl_next::Decode<
10775 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10776 Constraint = (),
10777 >,
10778{
10779 async fn on_one_way(
10780 handler: &mut ___H,
10781 ordinal: u64,
10782 flexibility: ::fidl_next::protocol::Flexibility,
10783 body: ::fidl_next::Body<___T>,
10784 ) -> ::core::result::Result<
10785 (),
10786 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10787 > {
10788 match ordinal {
10789 ordinal => {
10790 handler.on_unknown_interaction(ordinal).await;
10791 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10792 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10793 } else {
10794 Ok(())
10795 }
10796 }
10797 }
10798 }
10799
10800 async fn on_two_way(
10801 handler: &mut ___H,
10802 ordinal: u64,
10803 flexibility: ::fidl_next::protocol::Flexibility,
10804 body: ::fidl_next::Body<___T>,
10805 responder: ::fidl_next::protocol::Responder<___T>,
10806 ) -> ::core::result::Result<
10807 (),
10808 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10809 > {
10810 match ordinal {
10811 6727592627741008260 => {
10812 let responder = ::fidl_next::Responder::from_untyped(responder);
10813
10814 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10815 Ok(decoded) => {
10816 handler
10817 .duplicate(::fidl_next::Request::from_decoded(decoded), responder)
10818 .await;
10819 Ok(())
10820 }
10821 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10822 ordinal: 6727592627741008260,
10823 error,
10824 }),
10825 }
10826 }
10827
10828 753328233834620249 => {
10829 let responder = ::fidl_next::Responder::from_untyped(responder);
10830
10831 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10832 Ok(decoded) => {
10833 handler.drop(::fidl_next::Request::from_decoded(decoded), responder).await;
10834 Ok(())
10835 }
10836 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10837 ordinal: 753328233834620249,
10838 error,
10839 }),
10840 }
10841 }
10842
10843 226159162093533951 => {
10844 let responder = ::fidl_next::Responder::from_untyped(responder);
10845
10846 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10847 Ok(decoded) => {
10848 handler
10849 .export(::fidl_next::Request::from_decoded(decoded), responder)
10850 .await;
10851 Ok(())
10852 }
10853 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10854 ordinal: 226159162093533951,
10855 error,
10856 }),
10857 }
10858 }
10859
10860 2276030276116435867 => {
10861 let responder = ::fidl_next::Responder::from_untyped(responder);
10862
10863 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10864 Ok(decoded) => {
10865 handler
10866 .import(::fidl_next::Request::from_decoded(decoded), responder)
10867 .await;
10868 Ok(())
10869 }
10870 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10871 ordinal: 2276030276116435867,
10872 error,
10873 }),
10874 }
10875 }
10876
10877 2979461408102095909 => {
10878 let responder = ::fidl_next::Responder::from_untyped(responder);
10879
10880 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10881 Ok(decoded) => {
10882 handler
10883 .connector_create(
10884 ::fidl_next::Request::from_decoded(decoded),
10885 responder,
10886 )
10887 .await;
10888 Ok(())
10889 }
10890 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10891 ordinal: 2979461408102095909,
10892 error,
10893 }),
10894 }
10895 }
10896
10897 6016362336453278623 => {
10898 let responder = ::fidl_next::Responder::from_untyped(responder);
10899
10900 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10901 Ok(decoded) => {
10902 handler
10903 .connector_open(::fidl_next::Request::from_decoded(decoded), responder)
10904 .await;
10905 Ok(())
10906 }
10907 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10908 ordinal: 6016362336453278623,
10909 error,
10910 }),
10911 }
10912 }
10913
10914 1756747594275428795 => {
10915 let responder = ::fidl_next::Responder::from_untyped(responder);
10916
10917 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10918 Ok(decoded) => {
10919 handler
10920 .dir_connector_create(
10921 ::fidl_next::Request::from_decoded(decoded),
10922 responder,
10923 )
10924 .await;
10925 Ok(())
10926 }
10927 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10928 ordinal: 1756747594275428795,
10929 error,
10930 }),
10931 }
10932 }
10933
10934 6219704004220369153 => {
10935 let responder = ::fidl_next::Responder::from_untyped(responder);
10936
10937 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10938 Ok(decoded) => {
10939 handler
10940 .dir_connector_open(
10941 ::fidl_next::Request::from_decoded(decoded),
10942 responder,
10943 )
10944 .await;
10945 Ok(())
10946 }
10947 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10948 ordinal: 6219704004220369153,
10949 error,
10950 }),
10951 }
10952 }
10953
10954 7608770958894948499 => {
10955 let responder = ::fidl_next::Responder::from_untyped(responder);
10956
10957 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10958 Ok(decoded) => {
10959 handler
10960 .dictionary_create(
10961 ::fidl_next::Request::from_decoded(decoded),
10962 responder,
10963 )
10964 .await;
10965 Ok(())
10966 }
10967 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10968 ordinal: 7608770958894948499,
10969 error,
10970 }),
10971 }
10972 }
10973
10974 8285893703432012383 => {
10975 let responder = ::fidl_next::Responder::from_untyped(responder);
10976
10977 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10978 Ok(decoded) => {
10979 handler
10980 .dictionary_legacy_import(
10981 ::fidl_next::Request::from_decoded(decoded),
10982 responder,
10983 )
10984 .await;
10985 Ok(())
10986 }
10987 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10988 ordinal: 8285893703432012383,
10989 error,
10990 }),
10991 }
10992 }
10993
10994 4647175832683306445 => {
10995 let responder = ::fidl_next::Responder::from_untyped(responder);
10996
10997 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10998 Ok(decoded) => {
10999 handler
11000 .dictionary_legacy_export(
11001 ::fidl_next::Request::from_decoded(decoded),
11002 responder,
11003 )
11004 .await;
11005 Ok(())
11006 }
11007 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11008 ordinal: 4647175832683306445,
11009 error,
11010 }),
11011 }
11012 }
11013
11014 8575443262986538023 => {
11015 let responder = ::fidl_next::Responder::from_untyped(responder);
11016
11017 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11018 Ok(decoded) => {
11019 handler
11020 .dictionary_insert(
11021 ::fidl_next::Request::from_decoded(decoded),
11022 responder,
11023 )
11024 .await;
11025 Ok(())
11026 }
11027 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11028 ordinal: 8575443262986538023,
11029 error,
11030 }),
11031 }
11032 }
11033
11034 5592951026866236882 => {
11035 let responder = ::fidl_next::Responder::from_untyped(responder);
11036
11037 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11038 Ok(decoded) => {
11039 handler
11040 .dictionary_get(::fidl_next::Request::from_decoded(decoded), responder)
11041 .await;
11042 Ok(())
11043 }
11044 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11045 ordinal: 5592951026866236882,
11046 error,
11047 }),
11048 }
11049 }
11050
11051 343892214579320051 => {
11052 let responder = ::fidl_next::Responder::from_untyped(responder);
11053
11054 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11055 Ok(decoded) => {
11056 handler
11057 .dictionary_remove(
11058 ::fidl_next::Request::from_decoded(decoded),
11059 responder,
11060 )
11061 .await;
11062 Ok(())
11063 }
11064 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11065 ordinal: 343892214579320051,
11066 error,
11067 }),
11068 }
11069 }
11070
11071 3977783339739362383 => {
11072 let responder = ::fidl_next::Responder::from_untyped(responder);
11073
11074 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11075 Ok(decoded) => {
11076 handler
11077 .dictionary_copy(::fidl_next::Request::from_decoded(decoded), responder)
11078 .await;
11079 Ok(())
11080 }
11081 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11082 ordinal: 3977783339739362383,
11083 error,
11084 }),
11085 }
11086 }
11087
11088 597577248872787102 => {
11089 let responder = ::fidl_next::Responder::from_untyped(responder);
11090
11091 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11092 Ok(decoded) => {
11093 handler
11094 .dictionary_keys(::fidl_next::Request::from_decoded(decoded), responder)
11095 .await;
11096 Ok(())
11097 }
11098 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11099 ordinal: 597577248872787102,
11100 error,
11101 }),
11102 }
11103 }
11104
11105 964467096271472193 => {
11106 let responder = ::fidl_next::Responder::from_untyped(responder);
11107
11108 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11109 Ok(decoded) => {
11110 handler
11111 .dictionary_enumerate(
11112 ::fidl_next::Request::from_decoded(decoded),
11113 responder,
11114 )
11115 .await;
11116 Ok(())
11117 }
11118 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11119 ordinal: 964467096271472193,
11120 error,
11121 }),
11122 }
11123 }
11124
11125 2928364469569621208 => {
11126 let responder = ::fidl_next::Responder::from_untyped(responder);
11127
11128 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11129 Ok(decoded) => {
11130 handler
11131 .dictionary_drain(
11132 ::fidl_next::Request::from_decoded(decoded),
11133 responder,
11134 )
11135 .await;
11136 Ok(())
11137 }
11138 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11139 ordinal: 2928364469569621208,
11140 error,
11141 }),
11142 }
11143 }
11144
11145 5009147843253209178 => {
11146 let responder = ::fidl_next::Responder::from_untyped(responder);
11147
11148 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11149 Ok(decoded) => {
11150 handler
11151 .create_service_aggregate(
11152 ::fidl_next::Request::from_decoded(decoded),
11153 responder,
11154 )
11155 .await;
11156 Ok(())
11157 }
11158 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11159 ordinal: 5009147843253209178,
11160 error,
11161 }),
11162 }
11163 }
11164
11165 ordinal => {
11166 handler.on_unknown_interaction(ordinal).await;
11167 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11168 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11169 } else {
11170 responder
11171 .respond(
11172 ordinal,
11173 flexibility,
11174 ::fidl_next::Flexible::<()>::FrameworkErr(
11175 ::fidl_next::FrameworkError::UnknownMethod,
11176 ),
11177 )
11178 .expect("encoding a framework error should never fail")
11179 .await?;
11180 Ok(())
11181 }
11182 }
11183 }
11184 }
11185}
11186
11187#[derive(PartialEq, Debug)]
11189pub struct ConnectorRouter;
11190
11191impl ::fidl_next::Discoverable for ConnectorRouter {
11192 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
11193}
11194
11195#[cfg(target_os = "fuchsia")]
11196impl ::fidl_next::HasTransport for ConnectorRouter {
11197 type Transport = ::fidl_next::fuchsia::zx::Channel;
11198}
11199
11200pub mod connector_router {
11201 pub mod prelude {
11202 pub use crate::{
11203 ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
11204 connector_router,
11205 };
11206
11207 pub use crate::natural::ConnectorRouterRouteResponse;
11208
11209 pub use crate::natural::RouteRequest;
11210
11211 pub use crate::natural::RouterError;
11212 }
11213
11214 pub struct Route;
11215
11216 impl ::fidl_next::Method for Route {
11217 const ORDINAL: u64 = 8420527046218942310;
11218 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11219 ::fidl_next::protocol::Flexibility::Flexible;
11220
11221 type Protocol = crate::ConnectorRouter;
11222
11223 type Request = crate::wire::RouteRequest<'static>;
11224 }
11225
11226 impl ::fidl_next::TwoWayMethod for Route {
11227 type Response = ::fidl_next::wire::FlexibleResult<
11228 'static,
11229 crate::wire::ConnectorRouterRouteResponse,
11230 crate::wire::RouterError,
11231 >;
11232 }
11233
11234 impl<___R> ::fidl_next::Respond<___R> for Route {
11235 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11236
11237 fn respond(response: ___R) -> Self::Output {
11238 ::fidl_next::FlexibleResult::Ok(response)
11239 }
11240 }
11241
11242 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11243 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11244
11245 fn respond_err(response: ___R) -> Self::Output {
11246 ::fidl_next::FlexibleResult::Err(response)
11247 }
11248 }
11249
11250 mod ___detail {
11251 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
11252 where
11253 ___T: ::fidl_next::Transport,
11254 {
11255 type Client = ConnectorRouterClient<___T>;
11256 type Server = ConnectorRouterServer<___T>;
11257 }
11258
11259 #[repr(transparent)]
11261 pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
11262 #[allow(dead_code)]
11263 client: ::fidl_next::protocol::Client<___T>,
11264 }
11265
11266 impl<___T> ConnectorRouterClient<___T>
11267 where
11268 ___T: ::fidl_next::Transport,
11269 {
11270 pub fn route_with<___R>(
11271 &self,
11272 request: ___R,
11273 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11274 where
11275 ___R: ::fidl_next::Encode<
11276 crate::wire::RouteRequest<'static>,
11277 <___T as ::fidl_next::Transport>::SendBuffer,
11278 >,
11279 {
11280 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11281 8420527046218942310,
11282 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11283 request,
11284 ))
11285 }
11286 }
11287
11288 #[repr(transparent)]
11290 pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
11291 server: ::fidl_next::protocol::Server<___T>,
11292 }
11293
11294 impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
11295 }
11296}
11297
11298pub trait ConnectorRouterClientHandler<
11302 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11303 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11304>
11305{
11306 fn on_unknown_interaction(
11307 &mut self,
11308 ordinal: u64,
11309 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11310 ::core::future::ready(())
11311 }
11312}
11313
11314impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11315where
11316 ___T: ::fidl_next::Transport,
11317{
11318 async fn on_unknown_interaction(&mut self, _: u64) {}
11319}
11320
11321impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
11322where
11323 ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
11324 ___T: ::fidl_next::Transport,
11325{
11326 async fn on_event(
11327 handler: &mut ___H,
11328 ordinal: u64,
11329 flexibility: ::fidl_next::protocol::Flexibility,
11330 body: ::fidl_next::Body<___T>,
11331 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11332 match ordinal {
11333 ordinal => {
11334 handler.on_unknown_interaction(ordinal).await;
11335 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11336 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11337 } else {
11338 Ok(())
11339 }
11340 }
11341 }
11342 }
11343}
11344
11345pub trait ConnectorRouterServerHandler<
11349 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11350 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11351>
11352{
11353 fn route(
11354 &mut self,
11355
11356 request: ::fidl_next::Request<connector_router::Route, ___T>,
11357
11358 responder: ::fidl_next::Responder<connector_router::Route, ___T>,
11359 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11360
11361 fn on_unknown_interaction(
11362 &mut self,
11363 ordinal: u64,
11364 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11365 ::core::future::ready(())
11366 }
11367}
11368
11369impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
11370where
11371 ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
11372 ___T: ::fidl_next::Transport,
11373 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
11374 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11375 Constraint = (),
11376 >,
11377{
11378 async fn on_one_way(
11379 handler: &mut ___H,
11380 ordinal: u64,
11381 flexibility: ::fidl_next::protocol::Flexibility,
11382 body: ::fidl_next::Body<___T>,
11383 ) -> ::core::result::Result<
11384 (),
11385 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11386 > {
11387 match ordinal {
11388 ordinal => {
11389 handler.on_unknown_interaction(ordinal).await;
11390 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11391 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11392 } else {
11393 Ok(())
11394 }
11395 }
11396 }
11397 }
11398
11399 async fn on_two_way(
11400 handler: &mut ___H,
11401 ordinal: u64,
11402 flexibility: ::fidl_next::protocol::Flexibility,
11403 body: ::fidl_next::Body<___T>,
11404 responder: ::fidl_next::protocol::Responder<___T>,
11405 ) -> ::core::result::Result<
11406 (),
11407 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11408 > {
11409 match ordinal {
11410 8420527046218942310 => {
11411 let responder = ::fidl_next::Responder::from_untyped(responder);
11412
11413 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11414 Ok(decoded) => {
11415 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11416 Ok(())
11417 }
11418 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11419 ordinal: 8420527046218942310,
11420 error,
11421 }),
11422 }
11423 }
11424
11425 ordinal => {
11426 handler.on_unknown_interaction(ordinal).await;
11427 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11428 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11429 } else {
11430 responder
11431 .respond(
11432 ordinal,
11433 flexibility,
11434 ::fidl_next::Flexible::<()>::FrameworkErr(
11435 ::fidl_next::FrameworkError::UnknownMethod,
11436 ),
11437 )
11438 .expect("encoding a framework error should never fail")
11439 .await?;
11440 Ok(())
11441 }
11442 }
11443 }
11444 }
11445}
11446
11447#[derive(PartialEq, Debug)]
11449pub struct DataRouter;
11450
11451impl ::fidl_next::Discoverable for DataRouter {
11452 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
11453}
11454
11455#[cfg(target_os = "fuchsia")]
11456impl ::fidl_next::HasTransport for DataRouter {
11457 type Transport = ::fidl_next::fuchsia::zx::Channel;
11458}
11459
11460pub mod data_router {
11461 pub mod prelude {
11462 pub use crate::{
11463 DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
11464 };
11465
11466 pub use crate::natural::DataRouterRouteResponse;
11467
11468 pub use crate::natural::RouteRequest;
11469
11470 pub use crate::natural::RouterError;
11471 }
11472
11473 pub struct Route;
11474
11475 impl ::fidl_next::Method for Route {
11476 const ORDINAL: u64 = 3352890635970754564;
11477 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11478 ::fidl_next::protocol::Flexibility::Flexible;
11479
11480 type Protocol = crate::DataRouter;
11481
11482 type Request = crate::wire::RouteRequest<'static>;
11483 }
11484
11485 impl ::fidl_next::TwoWayMethod for Route {
11486 type Response = ::fidl_next::wire::FlexibleResult<
11487 'static,
11488 crate::wire::DataRouterRouteResponse<'static>,
11489 crate::wire::RouterError,
11490 >;
11491 }
11492
11493 impl<___R> ::fidl_next::Respond<___R> for Route {
11494 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11495
11496 fn respond(response: ___R) -> Self::Output {
11497 ::fidl_next::FlexibleResult::Ok(response)
11498 }
11499 }
11500
11501 impl<___R> ::fidl_next::RespondErr<___R> for Route {
11502 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11503
11504 fn respond_err(response: ___R) -> Self::Output {
11505 ::fidl_next::FlexibleResult::Err(response)
11506 }
11507 }
11508
11509 mod ___detail {
11510 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
11511 where
11512 ___T: ::fidl_next::Transport,
11513 {
11514 type Client = DataRouterClient<___T>;
11515 type Server = DataRouterServer<___T>;
11516 }
11517
11518 #[repr(transparent)]
11520 pub struct DataRouterClient<___T: ::fidl_next::Transport> {
11521 #[allow(dead_code)]
11522 client: ::fidl_next::protocol::Client<___T>,
11523 }
11524
11525 impl<___T> DataRouterClient<___T>
11526 where
11527 ___T: ::fidl_next::Transport,
11528 {
11529 pub fn route_with<___R>(
11530 &self,
11531 request: ___R,
11532 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
11533 where
11534 ___R: ::fidl_next::Encode<
11535 crate::wire::RouteRequest<'static>,
11536 <___T as ::fidl_next::Transport>::SendBuffer,
11537 >,
11538 {
11539 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11540 3352890635970754564,
11541 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
11542 request,
11543 ))
11544 }
11545 }
11546
11547 #[repr(transparent)]
11549 pub struct DataRouterServer<___T: ::fidl_next::Transport> {
11550 server: ::fidl_next::protocol::Server<___T>,
11551 }
11552
11553 impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
11554 }
11555}
11556
11557pub trait DataRouterClientHandler<
11561 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11562 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11563>
11564{
11565 fn on_unknown_interaction(
11566 &mut self,
11567 ordinal: u64,
11568 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11569 ::core::future::ready(())
11570 }
11571}
11572
11573impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
11574where
11575 ___T: ::fidl_next::Transport,
11576{
11577 async fn on_unknown_interaction(&mut self, _: u64) {}
11578}
11579
11580impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
11581where
11582 ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
11583 ___T: ::fidl_next::Transport,
11584{
11585 async fn on_event(
11586 handler: &mut ___H,
11587 ordinal: u64,
11588 flexibility: ::fidl_next::protocol::Flexibility,
11589 body: ::fidl_next::Body<___T>,
11590 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11591 match ordinal {
11592 ordinal => {
11593 handler.on_unknown_interaction(ordinal).await;
11594 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11595 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11596 } else {
11597 Ok(())
11598 }
11599 }
11600 }
11601 }
11602}
11603
11604pub trait DataRouterServerHandler<
11608 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11609 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11610>
11611{
11612 fn route(
11613 &mut self,
11614
11615 request: ::fidl_next::Request<data_router::Route, ___T>,
11616
11617 responder: ::fidl_next::Responder<data_router::Route, ___T>,
11618 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11619
11620 fn on_unknown_interaction(
11621 &mut self,
11622 ordinal: u64,
11623 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11624 ::core::future::ready(())
11625 }
11626}
11627
11628impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
11629where
11630 ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
11631 ___T: ::fidl_next::Transport,
11632 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
11633 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11634 Constraint = (),
11635 >,
11636{
11637 async fn on_one_way(
11638 handler: &mut ___H,
11639 ordinal: u64,
11640 flexibility: ::fidl_next::protocol::Flexibility,
11641 body: ::fidl_next::Body<___T>,
11642 ) -> ::core::result::Result<
11643 (),
11644 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11645 > {
11646 match ordinal {
11647 ordinal => {
11648 handler.on_unknown_interaction(ordinal).await;
11649 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11650 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11651 } else {
11652 Ok(())
11653 }
11654 }
11655 }
11656 }
11657
11658 async fn on_two_way(
11659 handler: &mut ___H,
11660 ordinal: u64,
11661 flexibility: ::fidl_next::protocol::Flexibility,
11662 body: ::fidl_next::Body<___T>,
11663 responder: ::fidl_next::protocol::Responder<___T>,
11664 ) -> ::core::result::Result<
11665 (),
11666 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11667 > {
11668 match ordinal {
11669 3352890635970754564 => {
11670 let responder = ::fidl_next::Responder::from_untyped(responder);
11671
11672 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11673 Ok(decoded) => {
11674 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
11675 Ok(())
11676 }
11677 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11678 ordinal: 3352890635970754564,
11679 error,
11680 }),
11681 }
11682 }
11683
11684 ordinal => {
11685 handler.on_unknown_interaction(ordinal).await;
11686 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11687 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11688 } else {
11689 responder
11690 .respond(
11691 ordinal,
11692 flexibility,
11693 ::fidl_next::Flexible::<()>::FrameworkErr(
11694 ::fidl_next::FrameworkError::UnknownMethod,
11695 ),
11696 )
11697 .expect("encoding a framework error should never fail")
11698 .await?;
11699 Ok(())
11700 }
11701 }
11702 }
11703 }
11704}
11705
11706#[derive(PartialEq, Debug)]
11708pub struct DictionaryDrainIterator;
11709
11710#[cfg(target_os = "fuchsia")]
11711impl ::fidl_next::HasTransport for DictionaryDrainIterator {
11712 type Transport = ::fidl_next::fuchsia::zx::Channel;
11713}
11714
11715pub mod dictionary_drain_iterator {
11716 pub mod prelude {
11717 pub use crate::{
11718 DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
11719 DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
11720 };
11721
11722 pub use crate::natural::CapabilityStoreError;
11723
11724 pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
11725
11726 pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
11727 }
11728
11729 pub struct GetNext;
11730
11731 impl ::fidl_next::Method for GetNext {
11732 const ORDINAL: u64 = 5728722530628427873;
11733 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11734 ::fidl_next::protocol::Flexibility::Flexible;
11735
11736 type Protocol = crate::DictionaryDrainIterator;
11737
11738 type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
11739 }
11740
11741 impl ::fidl_next::TwoWayMethod for GetNext {
11742 type Response = ::fidl_next::wire::FlexibleResult<
11743 'static,
11744 crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
11745 crate::wire::CapabilityStoreError,
11746 >;
11747 }
11748
11749 impl<___R> ::fidl_next::Respond<___R> for GetNext {
11750 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
11751
11752 fn respond(response: ___R) -> Self::Output {
11753 ::fidl_next::FlexibleResult::Ok(response)
11754 }
11755 }
11756
11757 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
11758 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
11759
11760 fn respond_err(response: ___R) -> Self::Output {
11761 ::fidl_next::FlexibleResult::Err(response)
11762 }
11763 }
11764
11765 mod ___detail {
11766 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
11767 where
11768 ___T: ::fidl_next::Transport,
11769 {
11770 type Client = DictionaryDrainIteratorClient<___T>;
11771 type Server = DictionaryDrainIteratorServer<___T>;
11772 }
11773
11774 #[repr(transparent)]
11776 pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
11777 #[allow(dead_code)]
11778 client: ::fidl_next::protocol::Client<___T>,
11779 }
11780
11781 impl<___T> DictionaryDrainIteratorClient<___T>
11782 where
11783 ___T: ::fidl_next::Transport,
11784 {
11785 #[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"]
11786 pub fn get_next(
11787 &self,
11788
11789 start_id: impl ::fidl_next::Encode<
11790 ::fidl_next::wire::Uint64,
11791 <___T as ::fidl_next::Transport>::SendBuffer,
11792 >,
11793
11794 limit: impl ::fidl_next::Encode<
11795 ::fidl_next::wire::Uint32,
11796 <___T as ::fidl_next::Transport>::SendBuffer,
11797 >,
11798 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11799 where
11800 <___T as ::fidl_next::Transport>::SendBuffer:
11801 ::fidl_next::encoder::InternalHandleEncoder,
11802 {
11803 self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
11804 start_id,
11805
11806 limit,
11807 })
11808 }
11809
11810 #[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"]
11811 pub fn get_next_with<___R>(
11812 &self,
11813 request: ___R,
11814 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11815 where
11816 ___R: ::fidl_next::Encode<
11817 crate::wire::DictionaryDrainIteratorGetNextRequest,
11818 <___T as ::fidl_next::Transport>::SendBuffer,
11819 >,
11820 {
11821 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11822 5728722530628427873,
11823 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
11824 request,
11825 ))
11826 }
11827 }
11828
11829 #[repr(transparent)]
11831 pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
11832 server: ::fidl_next::protocol::Server<___T>,
11833 }
11834
11835 impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11836 }
11837}
11838
11839pub trait DictionaryDrainIteratorClientHandler<
11843 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11844 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11845>
11846{
11847 fn on_unknown_interaction(
11848 &mut self,
11849 ordinal: u64,
11850 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11851 ::core::future::ready(())
11852 }
11853}
11854
11855impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
11856where
11857 ___T: ::fidl_next::Transport,
11858{
11859 async fn on_unknown_interaction(&mut self, _: u64) {}
11860}
11861
11862impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
11863where
11864 ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
11865 ___T: ::fidl_next::Transport,
11866{
11867 async fn on_event(
11868 handler: &mut ___H,
11869 ordinal: u64,
11870 flexibility: ::fidl_next::protocol::Flexibility,
11871 body: ::fidl_next::Body<___T>,
11872 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11873 match ordinal {
11874 ordinal => {
11875 handler.on_unknown_interaction(ordinal).await;
11876 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11877 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11878 } else {
11879 Ok(())
11880 }
11881 }
11882 }
11883 }
11884}
11885
11886pub trait DictionaryDrainIteratorServerHandler<
11890 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11891 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11892>
11893{
11894 #[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"]
11895 fn get_next(
11896 &mut self,
11897
11898 request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
11899
11900 responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
11901 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11902
11903 fn on_unknown_interaction(
11904 &mut self,
11905 ordinal: u64,
11906 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11907 ::core::future::ready(())
11908 }
11909}
11910
11911impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
11912where
11913 ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
11914 ___T: ::fidl_next::Transport,
11915 for<'de> crate::wire::DictionaryDrainIteratorGetNextRequest: ::fidl_next::Decode<
11916 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11917 Constraint = (),
11918 >,
11919{
11920 async fn on_one_way(
11921 handler: &mut ___H,
11922 ordinal: u64,
11923 flexibility: ::fidl_next::protocol::Flexibility,
11924 body: ::fidl_next::Body<___T>,
11925 ) -> ::core::result::Result<
11926 (),
11927 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11928 > {
11929 match ordinal {
11930 ordinal => {
11931 handler.on_unknown_interaction(ordinal).await;
11932 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11933 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11934 } else {
11935 Ok(())
11936 }
11937 }
11938 }
11939 }
11940
11941 async fn on_two_way(
11942 handler: &mut ___H,
11943 ordinal: u64,
11944 flexibility: ::fidl_next::protocol::Flexibility,
11945 body: ::fidl_next::Body<___T>,
11946 responder: ::fidl_next::protocol::Responder<___T>,
11947 ) -> ::core::result::Result<
11948 (),
11949 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11950 > {
11951 match ordinal {
11952 5728722530628427873 => {
11953 let responder = ::fidl_next::Responder::from_untyped(responder);
11954
11955 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11956 Ok(decoded) => {
11957 handler
11958 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
11959 .await;
11960 Ok(())
11961 }
11962 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11963 ordinal: 5728722530628427873,
11964 error,
11965 }),
11966 }
11967 }
11968
11969 ordinal => {
11970 handler.on_unknown_interaction(ordinal).await;
11971 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
11972 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11973 } else {
11974 responder
11975 .respond(
11976 ordinal,
11977 flexibility,
11978 ::fidl_next::Flexible::<()>::FrameworkErr(
11979 ::fidl_next::FrameworkError::UnknownMethod,
11980 ),
11981 )
11982 .expect("encoding a framework error should never fail")
11983 .await?;
11984 Ok(())
11985 }
11986 }
11987 }
11988 }
11989}
11990
11991#[derive(PartialEq, Debug)]
11993pub struct DictionaryEnumerateIterator;
11994
11995#[cfg(target_os = "fuchsia")]
11996impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
11997 type Transport = ::fidl_next::fuchsia::zx::Channel;
11998}
11999
12000pub mod dictionary_enumerate_iterator {
12001 pub mod prelude {
12002 pub use crate::{
12003 DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
12004 DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
12005 };
12006
12007 pub use crate::natural::CapabilityStoreError;
12008
12009 pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
12010
12011 pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
12012 }
12013
12014 pub struct GetNext;
12015
12016 impl ::fidl_next::Method for GetNext {
12017 const ORDINAL: u64 = 1511164556663256527;
12018 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12019 ::fidl_next::protocol::Flexibility::Flexible;
12020
12021 type Protocol = crate::DictionaryEnumerateIterator;
12022
12023 type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
12024 }
12025
12026 impl ::fidl_next::TwoWayMethod for GetNext {
12027 type Response = ::fidl_next::wire::FlexibleResult<
12028 'static,
12029 crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
12030 crate::wire::CapabilityStoreError,
12031 >;
12032 }
12033
12034 impl<___R> ::fidl_next::Respond<___R> for GetNext {
12035 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12036
12037 fn respond(response: ___R) -> Self::Output {
12038 ::fidl_next::FlexibleResult::Ok(response)
12039 }
12040 }
12041
12042 impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
12043 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12044
12045 fn respond_err(response: ___R) -> Self::Output {
12046 ::fidl_next::FlexibleResult::Err(response)
12047 }
12048 }
12049
12050 mod ___detail {
12051 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
12052 where
12053 ___T: ::fidl_next::Transport,
12054 {
12055 type Client = DictionaryEnumerateIteratorClient<___T>;
12056 type Server = DictionaryEnumerateIteratorServer<___T>;
12057 }
12058
12059 #[repr(transparent)]
12061 pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
12062 #[allow(dead_code)]
12063 client: ::fidl_next::protocol::Client<___T>,
12064 }
12065
12066 impl<___T> DictionaryEnumerateIteratorClient<___T>
12067 where
12068 ___T: ::fidl_next::Transport,
12069 {
12070 #[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"]
12071 pub fn get_next(
12072 &self,
12073
12074 start_id: impl ::fidl_next::Encode<
12075 ::fidl_next::wire::Uint64,
12076 <___T as ::fidl_next::Transport>::SendBuffer,
12077 >,
12078
12079 limit: impl ::fidl_next::Encode<
12080 ::fidl_next::wire::Uint32,
12081 <___T as ::fidl_next::Transport>::SendBuffer,
12082 >,
12083 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
12084 where
12085 <___T as ::fidl_next::Transport>::SendBuffer:
12086 ::fidl_next::encoder::InternalHandleEncoder,
12087 {
12088 self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
12089 start_id,
12090
12091 limit,
12092 })
12093 }
12094
12095 #[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"]
12096 pub fn get_next_with<___R>(
12097 &self,
12098 request: ___R,
12099 ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
12100 where
12101 ___R: ::fidl_next::Encode<
12102 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
12103 <___T as ::fidl_next::Transport>::SendBuffer,
12104 >,
12105 {
12106 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12107 1511164556663256527,
12108 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
12109 request,
12110 ))
12111 }
12112 }
12113
12114 #[repr(transparent)]
12116 pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
12117 server: ::fidl_next::protocol::Server<___T>,
12118 }
12119
12120 impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
12121 }
12122}
12123
12124pub trait DictionaryEnumerateIteratorClientHandler<
12128 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12129 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12130>
12131{
12132 fn on_unknown_interaction(
12133 &mut self,
12134 ordinal: u64,
12135 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12136 ::core::future::ready(())
12137 }
12138}
12139
12140impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
12141where
12142 ___T: ::fidl_next::Transport,
12143{
12144 async fn on_unknown_interaction(&mut self, _: u64) {}
12145}
12146
12147impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
12148where
12149 ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
12150 ___T: ::fidl_next::Transport,
12151{
12152 async fn on_event(
12153 handler: &mut ___H,
12154 ordinal: u64,
12155 flexibility: ::fidl_next::protocol::Flexibility,
12156 body: ::fidl_next::Body<___T>,
12157 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12158 match ordinal {
12159 ordinal => {
12160 handler.on_unknown_interaction(ordinal).await;
12161 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12162 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12163 } else {
12164 Ok(())
12165 }
12166 }
12167 }
12168 }
12169}
12170
12171pub trait DictionaryEnumerateIteratorServerHandler<
12175 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12176 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12177>
12178{
12179 #[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"]
12180 fn get_next(
12181 &mut self,
12182
12183 request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
12184
12185 responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
12186 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12187
12188 fn on_unknown_interaction(
12189 &mut self,
12190 ordinal: u64,
12191 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12192 ::core::future::ready(())
12193 }
12194}
12195
12196impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
12197where
12198 ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
12199 ___T: ::fidl_next::Transport,
12200 for<'de> crate::wire::DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Decode<
12201 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12202 Constraint = (),
12203 >,
12204{
12205 async fn on_one_way(
12206 handler: &mut ___H,
12207 ordinal: u64,
12208 flexibility: ::fidl_next::protocol::Flexibility,
12209 body: ::fidl_next::Body<___T>,
12210 ) -> ::core::result::Result<
12211 (),
12212 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12213 > {
12214 match ordinal {
12215 ordinal => {
12216 handler.on_unknown_interaction(ordinal).await;
12217 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12218 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12219 } else {
12220 Ok(())
12221 }
12222 }
12223 }
12224 }
12225
12226 async fn on_two_way(
12227 handler: &mut ___H,
12228 ordinal: u64,
12229 flexibility: ::fidl_next::protocol::Flexibility,
12230 body: ::fidl_next::Body<___T>,
12231 responder: ::fidl_next::protocol::Responder<___T>,
12232 ) -> ::core::result::Result<
12233 (),
12234 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12235 > {
12236 match ordinal {
12237 1511164556663256527 => {
12238 let responder = ::fidl_next::Responder::from_untyped(responder);
12239
12240 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12241 Ok(decoded) => {
12242 handler
12243 .get_next(::fidl_next::Request::from_decoded(decoded), responder)
12244 .await;
12245 Ok(())
12246 }
12247 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12248 ordinal: 1511164556663256527,
12249 error,
12250 }),
12251 }
12252 }
12253
12254 ordinal => {
12255 handler.on_unknown_interaction(ordinal).await;
12256 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12257 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12258 } else {
12259 responder
12260 .respond(
12261 ordinal,
12262 flexibility,
12263 ::fidl_next::Flexible::<()>::FrameworkErr(
12264 ::fidl_next::FrameworkError::UnknownMethod,
12265 ),
12266 )
12267 .expect("encoding a framework error should never fail")
12268 .await?;
12269 Ok(())
12270 }
12271 }
12272 }
12273 }
12274}
12275
12276#[derive(PartialEq, Debug)]
12278pub struct DictionaryKeysIterator;
12279
12280#[cfg(target_os = "fuchsia")]
12281impl ::fidl_next::HasTransport for DictionaryKeysIterator {
12282 type Transport = ::fidl_next::fuchsia::zx::Channel;
12283}
12284
12285pub mod dictionary_keys_iterator {
12286 pub mod prelude {
12287 pub use crate::{
12288 DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
12289 DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
12290 };
12291
12292 pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
12293 }
12294
12295 pub struct GetNext;
12296
12297 impl ::fidl_next::Method for GetNext {
12298 const ORDINAL: u64 = 4987781442555247955;
12299 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12300 ::fidl_next::protocol::Flexibility::Flexible;
12301
12302 type Protocol = crate::DictionaryKeysIterator;
12303
12304 type Request = ();
12305 }
12306
12307 impl ::fidl_next::TwoWayMethod for GetNext {
12308 type Response = ::fidl_next::wire::Flexible<
12309 'static,
12310 crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
12311 >;
12312 }
12313
12314 impl<___R> ::fidl_next::Respond<___R> for GetNext {
12315 type Output =
12316 ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
12317
12318 fn respond(response: ___R) -> Self::Output {
12319 ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
12320 keys: response,
12321 })
12322 }
12323 }
12324
12325 mod ___detail {
12326 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
12327 where
12328 ___T: ::fidl_next::Transport,
12329 {
12330 type Client = DictionaryKeysIteratorClient<___T>;
12331 type Server = DictionaryKeysIteratorServer<___T>;
12332 }
12333
12334 #[repr(transparent)]
12336 pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
12337 #[allow(dead_code)]
12338 client: ::fidl_next::protocol::Client<___T>,
12339 }
12340
12341 impl<___T> DictionaryKeysIteratorClient<___T>
12342 where
12343 ___T: ::fidl_next::Transport,
12344 {
12345 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
12346 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12347 4987781442555247955,
12348 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
12349 (),
12350 ))
12351 }
12352 }
12353
12354 #[repr(transparent)]
12356 pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
12357 server: ::fidl_next::protocol::Server<___T>,
12358 }
12359
12360 impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
12361 }
12362}
12363
12364pub trait DictionaryKeysIteratorClientHandler<
12368 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12369 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12370>
12371{
12372 fn on_unknown_interaction(
12373 &mut self,
12374 ordinal: u64,
12375 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12376 ::core::future::ready(())
12377 }
12378}
12379
12380impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
12381where
12382 ___T: ::fidl_next::Transport,
12383{
12384 async fn on_unknown_interaction(&mut self, _: u64) {}
12385}
12386
12387impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
12388where
12389 ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
12390 ___T: ::fidl_next::Transport,
12391{
12392 async fn on_event(
12393 handler: &mut ___H,
12394 ordinal: u64,
12395 flexibility: ::fidl_next::protocol::Flexibility,
12396 body: ::fidl_next::Body<___T>,
12397 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12398 match ordinal {
12399 ordinal => {
12400 handler.on_unknown_interaction(ordinal).await;
12401 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12402 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12403 } else {
12404 Ok(())
12405 }
12406 }
12407 }
12408 }
12409}
12410
12411pub trait DictionaryKeysIteratorServerHandler<
12415 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12416 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12417>
12418{
12419 fn get_next(
12420 &mut self,
12421
12422 responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
12423 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12424
12425 fn on_unknown_interaction(
12426 &mut self,
12427 ordinal: u64,
12428 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12429 ::core::future::ready(())
12430 }
12431}
12432
12433impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
12434where
12435 ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
12436 ___T: ::fidl_next::Transport,
12437{
12438 async fn on_one_way(
12439 handler: &mut ___H,
12440 ordinal: u64,
12441 flexibility: ::fidl_next::protocol::Flexibility,
12442 body: ::fidl_next::Body<___T>,
12443 ) -> ::core::result::Result<
12444 (),
12445 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12446 > {
12447 match ordinal {
12448 ordinal => {
12449 handler.on_unknown_interaction(ordinal).await;
12450 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12451 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12452 } else {
12453 Ok(())
12454 }
12455 }
12456 }
12457 }
12458
12459 async fn on_two_way(
12460 handler: &mut ___H,
12461 ordinal: u64,
12462 flexibility: ::fidl_next::protocol::Flexibility,
12463 body: ::fidl_next::Body<___T>,
12464 responder: ::fidl_next::protocol::Responder<___T>,
12465 ) -> ::core::result::Result<
12466 (),
12467 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12468 > {
12469 match ordinal {
12470 4987781442555247955 => {
12471 let responder = ::fidl_next::Responder::from_untyped(responder);
12472
12473 handler.get_next(responder).await;
12474 Ok(())
12475 }
12476
12477 ordinal => {
12478 handler.on_unknown_interaction(ordinal).await;
12479 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12480 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12481 } else {
12482 responder
12483 .respond(
12484 ordinal,
12485 flexibility,
12486 ::fidl_next::Flexible::<()>::FrameworkErr(
12487 ::fidl_next::FrameworkError::UnknownMethod,
12488 ),
12489 )
12490 .expect("encoding a framework error should never fail")
12491 .await?;
12492 Ok(())
12493 }
12494 }
12495 }
12496 }
12497}
12498
12499#[derive(PartialEq, Debug)]
12501pub struct DictionaryRouter;
12502
12503impl ::fidl_next::Discoverable for DictionaryRouter {
12504 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
12505}
12506
12507#[cfg(target_os = "fuchsia")]
12508impl ::fidl_next::HasTransport for DictionaryRouter {
12509 type Transport = ::fidl_next::fuchsia::zx::Channel;
12510}
12511
12512pub mod dictionary_router {
12513 pub mod prelude {
12514 pub use crate::{
12515 DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
12516 dictionary_router,
12517 };
12518
12519 pub use crate::natural::DictionaryRouterRouteResponse;
12520
12521 pub use crate::natural::RouteRequest;
12522
12523 pub use crate::natural::RouterError;
12524 }
12525
12526 pub struct Route;
12527
12528 impl ::fidl_next::Method for Route {
12529 const ORDINAL: u64 = 8164012099375978399;
12530 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12531 ::fidl_next::protocol::Flexibility::Flexible;
12532
12533 type Protocol = crate::DictionaryRouter;
12534
12535 type Request = crate::wire::RouteRequest<'static>;
12536 }
12537
12538 impl ::fidl_next::TwoWayMethod for Route {
12539 type Response = ::fidl_next::wire::FlexibleResult<
12540 'static,
12541 crate::wire::DictionaryRouterRouteResponse,
12542 crate::wire::RouterError,
12543 >;
12544 }
12545
12546 impl<___R> ::fidl_next::Respond<___R> for Route {
12547 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12548
12549 fn respond(response: ___R) -> Self::Output {
12550 ::fidl_next::FlexibleResult::Ok(response)
12551 }
12552 }
12553
12554 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12555 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12556
12557 fn respond_err(response: ___R) -> Self::Output {
12558 ::fidl_next::FlexibleResult::Err(response)
12559 }
12560 }
12561
12562 mod ___detail {
12563 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
12564 where
12565 ___T: ::fidl_next::Transport,
12566 {
12567 type Client = DictionaryRouterClient<___T>;
12568 type Server = DictionaryRouterServer<___T>;
12569 }
12570
12571 #[repr(transparent)]
12573 pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
12574 #[allow(dead_code)]
12575 client: ::fidl_next::protocol::Client<___T>,
12576 }
12577
12578 impl<___T> DictionaryRouterClient<___T>
12579 where
12580 ___T: ::fidl_next::Transport,
12581 {
12582 pub fn route_with<___R>(
12583 &self,
12584 request: ___R,
12585 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12586 where
12587 ___R: ::fidl_next::Encode<
12588 crate::wire::RouteRequest<'static>,
12589 <___T as ::fidl_next::Transport>::SendBuffer,
12590 >,
12591 {
12592 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12593 8164012099375978399,
12594 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12595 request,
12596 ))
12597 }
12598 }
12599
12600 #[repr(transparent)]
12602 pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
12603 server: ::fidl_next::protocol::Server<___T>,
12604 }
12605
12606 impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12607 }
12608}
12609
12610pub trait DictionaryRouterClientHandler<
12614 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12615 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12616>
12617{
12618 fn on_unknown_interaction(
12619 &mut self,
12620 ordinal: u64,
12621 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12622 ::core::future::ready(())
12623 }
12624}
12625
12626impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12627where
12628 ___T: ::fidl_next::Transport,
12629{
12630 async fn on_unknown_interaction(&mut self, _: u64) {}
12631}
12632
12633impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
12634where
12635 ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
12636 ___T: ::fidl_next::Transport,
12637{
12638 async fn on_event(
12639 handler: &mut ___H,
12640 ordinal: u64,
12641 flexibility: ::fidl_next::protocol::Flexibility,
12642 body: ::fidl_next::Body<___T>,
12643 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12644 match ordinal {
12645 ordinal => {
12646 handler.on_unknown_interaction(ordinal).await;
12647 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12648 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12649 } else {
12650 Ok(())
12651 }
12652 }
12653 }
12654 }
12655}
12656
12657pub trait DictionaryRouterServerHandler<
12661 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12662 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12663>
12664{
12665 fn route(
12666 &mut self,
12667
12668 request: ::fidl_next::Request<dictionary_router::Route, ___T>,
12669
12670 responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
12671 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12672
12673 fn on_unknown_interaction(
12674 &mut self,
12675 ordinal: u64,
12676 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12677 ::core::future::ready(())
12678 }
12679}
12680
12681impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
12682where
12683 ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
12684 ___T: ::fidl_next::Transport,
12685 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
12686 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12687 Constraint = (),
12688 >,
12689{
12690 async fn on_one_way(
12691 handler: &mut ___H,
12692 ordinal: u64,
12693 flexibility: ::fidl_next::protocol::Flexibility,
12694 body: ::fidl_next::Body<___T>,
12695 ) -> ::core::result::Result<
12696 (),
12697 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12698 > {
12699 match ordinal {
12700 ordinal => {
12701 handler.on_unknown_interaction(ordinal).await;
12702 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12703 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12704 } else {
12705 Ok(())
12706 }
12707 }
12708 }
12709 }
12710
12711 async fn on_two_way(
12712 handler: &mut ___H,
12713 ordinal: u64,
12714 flexibility: ::fidl_next::protocol::Flexibility,
12715 body: ::fidl_next::Body<___T>,
12716 responder: ::fidl_next::protocol::Responder<___T>,
12717 ) -> ::core::result::Result<
12718 (),
12719 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12720 > {
12721 match ordinal {
12722 8164012099375978399 => {
12723 let responder = ::fidl_next::Responder::from_untyped(responder);
12724
12725 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12726 Ok(decoded) => {
12727 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12728 Ok(())
12729 }
12730 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12731 ordinal: 8164012099375978399,
12732 error,
12733 }),
12734 }
12735 }
12736
12737 ordinal => {
12738 handler.on_unknown_interaction(ordinal).await;
12739 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12740 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12741 } else {
12742 responder
12743 .respond(
12744 ordinal,
12745 flexibility,
12746 ::fidl_next::Flexible::<()>::FrameworkErr(
12747 ::fidl_next::FrameworkError::UnknownMethod,
12748 ),
12749 )
12750 .expect("encoding a framework error should never fail")
12751 .await?;
12752 Ok(())
12753 }
12754 }
12755 }
12756 }
12757}
12758
12759#[derive(PartialEq, Debug)]
12761pub struct DirConnectorRouter;
12762
12763impl ::fidl_next::Discoverable for DirConnectorRouter {
12764 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
12765}
12766
12767#[cfg(target_os = "fuchsia")]
12768impl ::fidl_next::HasTransport for DirConnectorRouter {
12769 type Transport = ::fidl_next::fuchsia::zx::Channel;
12770}
12771
12772pub mod dir_connector_router {
12773 pub mod prelude {
12774 pub use crate::{
12775 DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
12776 dir_connector_router,
12777 };
12778
12779 pub use crate::natural::DirConnectorRouterRouteResponse;
12780
12781 pub use crate::natural::RouteRequest;
12782
12783 pub use crate::natural::RouterError;
12784 }
12785
12786 pub struct Route;
12787
12788 impl ::fidl_next::Method for Route {
12789 const ORDINAL: u64 = 972231070188342848;
12790 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12791 ::fidl_next::protocol::Flexibility::Flexible;
12792
12793 type Protocol = crate::DirConnectorRouter;
12794
12795 type Request = crate::wire::RouteRequest<'static>;
12796 }
12797
12798 impl ::fidl_next::TwoWayMethod for Route {
12799 type Response = ::fidl_next::wire::FlexibleResult<
12800 'static,
12801 crate::wire::DirConnectorRouterRouteResponse,
12802 crate::wire::RouterError,
12803 >;
12804 }
12805
12806 impl<___R> ::fidl_next::Respond<___R> for Route {
12807 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
12808
12809 fn respond(response: ___R) -> Self::Output {
12810 ::fidl_next::FlexibleResult::Ok(response)
12811 }
12812 }
12813
12814 impl<___R> ::fidl_next::RespondErr<___R> for Route {
12815 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
12816
12817 fn respond_err(response: ___R) -> Self::Output {
12818 ::fidl_next::FlexibleResult::Err(response)
12819 }
12820 }
12821
12822 mod ___detail {
12823 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
12824 where
12825 ___T: ::fidl_next::Transport,
12826 {
12827 type Client = DirConnectorRouterClient<___T>;
12828 type Server = DirConnectorRouterServer<___T>;
12829 }
12830
12831 #[repr(transparent)]
12833 pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
12834 #[allow(dead_code)]
12835 client: ::fidl_next::protocol::Client<___T>,
12836 }
12837
12838 impl<___T> DirConnectorRouterClient<___T>
12839 where
12840 ___T: ::fidl_next::Transport,
12841 {
12842 pub fn route_with<___R>(
12843 &self,
12844 request: ___R,
12845 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12846 where
12847 ___R: ::fidl_next::Encode<
12848 crate::wire::RouteRequest<'static>,
12849 <___T as ::fidl_next::Transport>::SendBuffer,
12850 >,
12851 {
12852 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12853 972231070188342848,
12854 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
12855 request,
12856 ))
12857 }
12858 }
12859
12860 #[repr(transparent)]
12862 pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
12863 server: ::fidl_next::protocol::Server<___T>,
12864 }
12865
12866 impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
12867 }
12868}
12869
12870pub trait DirConnectorRouterClientHandler<
12874 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12875 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12876>
12877{
12878 fn on_unknown_interaction(
12879 &mut self,
12880 ordinal: u64,
12881 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12882 ::core::future::ready(())
12883 }
12884}
12885
12886impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
12887where
12888 ___T: ::fidl_next::Transport,
12889{
12890 async fn on_unknown_interaction(&mut self, _: u64) {}
12891}
12892
12893impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
12894where
12895 ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
12896 ___T: ::fidl_next::Transport,
12897{
12898 async fn on_event(
12899 handler: &mut ___H,
12900 ordinal: u64,
12901 flexibility: ::fidl_next::protocol::Flexibility,
12902 body: ::fidl_next::Body<___T>,
12903 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12904 match ordinal {
12905 ordinal => {
12906 handler.on_unknown_interaction(ordinal).await;
12907 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12908 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12909 } else {
12910 Ok(())
12911 }
12912 }
12913 }
12914 }
12915}
12916
12917pub trait DirConnectorRouterServerHandler<
12921 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12922 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12923>
12924{
12925 fn route(
12926 &mut self,
12927
12928 request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
12929
12930 responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
12931 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12932
12933 fn on_unknown_interaction(
12934 &mut self,
12935 ordinal: u64,
12936 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12937 ::core::future::ready(())
12938 }
12939}
12940
12941impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
12942where
12943 ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
12944 ___T: ::fidl_next::Transport,
12945 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
12946 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12947 Constraint = (),
12948 >,
12949{
12950 async fn on_one_way(
12951 handler: &mut ___H,
12952 ordinal: u64,
12953 flexibility: ::fidl_next::protocol::Flexibility,
12954 body: ::fidl_next::Body<___T>,
12955 ) -> ::core::result::Result<
12956 (),
12957 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12958 > {
12959 match ordinal {
12960 ordinal => {
12961 handler.on_unknown_interaction(ordinal).await;
12962 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
12963 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12964 } else {
12965 Ok(())
12966 }
12967 }
12968 }
12969 }
12970
12971 async fn on_two_way(
12972 handler: &mut ___H,
12973 ordinal: u64,
12974 flexibility: ::fidl_next::protocol::Flexibility,
12975 body: ::fidl_next::Body<___T>,
12976 responder: ::fidl_next::protocol::Responder<___T>,
12977 ) -> ::core::result::Result<
12978 (),
12979 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12980 > {
12981 match ordinal {
12982 972231070188342848 => {
12983 let responder = ::fidl_next::Responder::from_untyped(responder);
12984
12985 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12986 Ok(decoded) => {
12987 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
12988 Ok(())
12989 }
12990 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12991 ordinal: 972231070188342848,
12992 error,
12993 }),
12994 }
12995 }
12996
12997 ordinal => {
12998 handler.on_unknown_interaction(ordinal).await;
12999 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13000 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13001 } else {
13002 responder
13003 .respond(
13004 ordinal,
13005 flexibility,
13006 ::fidl_next::Flexible::<()>::FrameworkErr(
13007 ::fidl_next::FrameworkError::UnknownMethod,
13008 ),
13009 )
13010 .expect("encoding a framework error should never fail")
13011 .await?;
13012 Ok(())
13013 }
13014 }
13015 }
13016 }
13017}
13018
13019#[derive(PartialEq, Debug)]
13021pub struct DirEntryRouter;
13022
13023impl ::fidl_next::Discoverable for DirEntryRouter {
13024 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
13025}
13026
13027#[cfg(target_os = "fuchsia")]
13028impl ::fidl_next::HasTransport for DirEntryRouter {
13029 type Transport = ::fidl_next::fuchsia::zx::Channel;
13030}
13031
13032pub mod dir_entry_router {
13033 pub mod prelude {
13034 pub use crate::{
13035 DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
13036 dir_entry_router,
13037 };
13038
13039 pub use crate::natural::DirEntryRouterRouteResponse;
13040
13041 pub use crate::natural::RouteRequest;
13042
13043 pub use crate::natural::RouterError;
13044 }
13045
13046 pub struct Route;
13047
13048 impl ::fidl_next::Method for Route {
13049 const ORDINAL: u64 = 1929392218567642066;
13050 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13051 ::fidl_next::protocol::Flexibility::Flexible;
13052
13053 type Protocol = crate::DirEntryRouter;
13054
13055 type Request = crate::wire::RouteRequest<'static>;
13056 }
13057
13058 impl ::fidl_next::TwoWayMethod for Route {
13059 type Response = ::fidl_next::wire::FlexibleResult<
13060 'static,
13061 crate::wire::DirEntryRouterRouteResponse,
13062 crate::wire::RouterError,
13063 >;
13064 }
13065
13066 impl<___R> ::fidl_next::Respond<___R> for Route {
13067 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13068
13069 fn respond(response: ___R) -> Self::Output {
13070 ::fidl_next::FlexibleResult::Ok(response)
13071 }
13072 }
13073
13074 impl<___R> ::fidl_next::RespondErr<___R> for Route {
13075 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13076
13077 fn respond_err(response: ___R) -> Self::Output {
13078 ::fidl_next::FlexibleResult::Err(response)
13079 }
13080 }
13081
13082 mod ___detail {
13083 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
13084 where
13085 ___T: ::fidl_next::Transport,
13086 {
13087 type Client = DirEntryRouterClient<___T>;
13088 type Server = DirEntryRouterServer<___T>;
13089 }
13090
13091 #[repr(transparent)]
13093 pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
13094 #[allow(dead_code)]
13095 client: ::fidl_next::protocol::Client<___T>,
13096 }
13097
13098 impl<___T> DirEntryRouterClient<___T>
13099 where
13100 ___T: ::fidl_next::Transport,
13101 {
13102 pub fn route_with<___R>(
13103 &self,
13104 request: ___R,
13105 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13106 where
13107 ___R: ::fidl_next::Encode<
13108 crate::wire::RouteRequest<'static>,
13109 <___T as ::fidl_next::Transport>::SendBuffer,
13110 >,
13111 {
13112 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13113 1929392218567642066,
13114 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
13115 request,
13116 ))
13117 }
13118 }
13119
13120 #[repr(transparent)]
13122 pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
13123 server: ::fidl_next::protocol::Server<___T>,
13124 }
13125
13126 impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
13127 }
13128}
13129
13130pub trait DirEntryRouterClientHandler<
13134 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13135 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13136>
13137{
13138 fn on_unknown_interaction(
13139 &mut self,
13140 ordinal: u64,
13141 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13142 ::core::future::ready(())
13143 }
13144}
13145
13146impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
13147where
13148 ___T: ::fidl_next::Transport,
13149{
13150 async fn on_unknown_interaction(&mut self, _: u64) {}
13151}
13152
13153impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
13154where
13155 ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
13156 ___T: ::fidl_next::Transport,
13157{
13158 async fn on_event(
13159 handler: &mut ___H,
13160 ordinal: u64,
13161 flexibility: ::fidl_next::protocol::Flexibility,
13162 body: ::fidl_next::Body<___T>,
13163 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13164 match ordinal {
13165 ordinal => {
13166 handler.on_unknown_interaction(ordinal).await;
13167 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13168 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13169 } else {
13170 Ok(())
13171 }
13172 }
13173 }
13174 }
13175}
13176
13177pub trait DirEntryRouterServerHandler<
13181 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13182 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13183>
13184{
13185 fn route(
13186 &mut self,
13187
13188 request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
13189
13190 responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
13191 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13192
13193 fn on_unknown_interaction(
13194 &mut self,
13195 ordinal: u64,
13196 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13197 ::core::future::ready(())
13198 }
13199}
13200
13201impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
13202where
13203 ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
13204 ___T: ::fidl_next::Transport,
13205 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13206 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13207 Constraint = (),
13208 >,
13209{
13210 async fn on_one_way(
13211 handler: &mut ___H,
13212 ordinal: u64,
13213 flexibility: ::fidl_next::protocol::Flexibility,
13214 body: ::fidl_next::Body<___T>,
13215 ) -> ::core::result::Result<
13216 (),
13217 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13218 > {
13219 match ordinal {
13220 ordinal => {
13221 handler.on_unknown_interaction(ordinal).await;
13222 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13223 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13224 } else {
13225 Ok(())
13226 }
13227 }
13228 }
13229 }
13230
13231 async fn on_two_way(
13232 handler: &mut ___H,
13233 ordinal: u64,
13234 flexibility: ::fidl_next::protocol::Flexibility,
13235 body: ::fidl_next::Body<___T>,
13236 responder: ::fidl_next::protocol::Responder<___T>,
13237 ) -> ::core::result::Result<
13238 (),
13239 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13240 > {
13241 match ordinal {
13242 1929392218567642066 => {
13243 let responder = ::fidl_next::Responder::from_untyped(responder);
13244
13245 match ::fidl_next::AsDecoderExt::into_decoded(body) {
13246 Ok(decoded) => {
13247 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13248 Ok(())
13249 }
13250 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13251 ordinal: 1929392218567642066,
13252 error,
13253 }),
13254 }
13255 }
13256
13257 ordinal => {
13258 handler.on_unknown_interaction(ordinal).await;
13259 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13260 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13261 } else {
13262 responder
13263 .respond(
13264 ordinal,
13265 flexibility,
13266 ::fidl_next::Flexible::<()>::FrameworkErr(
13267 ::fidl_next::FrameworkError::UnknownMethod,
13268 ),
13269 )
13270 .expect("encoding a framework error should never fail")
13271 .await?;
13272 Ok(())
13273 }
13274 }
13275 }
13276 }
13277}
13278
13279#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
13281#[derive(PartialEq, Debug)]
13282pub struct DirReceiver;
13283
13284impl ::fidl_next::Discoverable for DirReceiver {
13285 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
13286}
13287
13288#[cfg(target_os = "fuchsia")]
13289impl ::fidl_next::HasTransport for DirReceiver {
13290 type Transport = ::fidl_next::fuchsia::zx::Channel;
13291}
13292
13293pub mod dir_receiver {
13294 pub mod prelude {
13295 pub use crate::{
13296 DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
13297 };
13298
13299 pub use crate::natural::DirReceiverReceiveRequest;
13300 }
13301
13302 pub struct Receive;
13303
13304 impl ::fidl_next::Method for Receive {
13305 const ORDINAL: u64 = 926684461087488948;
13306 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13307 ::fidl_next::protocol::Flexibility::Flexible;
13308
13309 type Protocol = crate::DirReceiver;
13310
13311 type Request = crate::wire::DirReceiverReceiveRequest<'static>;
13312 }
13313
13314 mod ___detail {
13315 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
13316 where
13317 ___T: ::fidl_next::Transport,
13318 {
13319 type Client = DirReceiverClient<___T>;
13320 type Server = DirReceiverServer<___T>;
13321 }
13322
13323 #[repr(transparent)]
13325 pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
13326 #[allow(dead_code)]
13327 client: ::fidl_next::protocol::Client<___T>,
13328 }
13329
13330 impl<___T> DirReceiverClient<___T>
13331 where
13332 ___T: ::fidl_next::Transport,
13333 {
13334 #[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"]
13335 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
13336 where
13337 ___R: ::fidl_next::Encode<
13338 crate::wire::DirReceiverReceiveRequest<'static>,
13339 <___T as ::fidl_next::Transport>::SendBuffer,
13340 >,
13341 {
13342 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
13343 926684461087488948,
13344 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
13345 request,
13346 ))
13347 }
13348 }
13349
13350 #[repr(transparent)]
13352 pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
13353 server: ::fidl_next::protocol::Server<___T>,
13354 }
13355
13356 impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
13357 }
13358}
13359
13360pub trait DirReceiverClientHandler<
13364 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13365 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13366>
13367{
13368 fn on_unknown_interaction(
13369 &mut self,
13370 ordinal: u64,
13371 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13372 ::core::future::ready(())
13373 }
13374}
13375
13376impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
13377where
13378 ___T: ::fidl_next::Transport,
13379{
13380 async fn on_unknown_interaction(&mut self, _: u64) {}
13381}
13382
13383impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
13384where
13385 ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
13386 ___T: ::fidl_next::Transport,
13387{
13388 async fn on_event(
13389 handler: &mut ___H,
13390 ordinal: u64,
13391 flexibility: ::fidl_next::protocol::Flexibility,
13392 body: ::fidl_next::Body<___T>,
13393 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13394 match ordinal {
13395 ordinal => {
13396 handler.on_unknown_interaction(ordinal).await;
13397 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13398 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13399 } else {
13400 Ok(())
13401 }
13402 }
13403 }
13404 }
13405}
13406
13407pub trait DirReceiverServerHandler<
13411 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13412 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13413>
13414{
13415 #[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"]
13416 fn receive(
13417 &mut self,
13418
13419 request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
13420 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13421
13422 fn on_unknown_interaction(
13423 &mut self,
13424 ordinal: u64,
13425 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13426 ::core::future::ready(())
13427 }
13428}
13429
13430impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
13431where
13432 ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
13433 ___T: ::fidl_next::Transport,
13434 for<'de> crate::wire::DirReceiverReceiveRequest<'de>: ::fidl_next::Decode<
13435 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13436 Constraint = (),
13437 >,
13438{
13439 async fn on_one_way(
13440 handler: &mut ___H,
13441 ordinal: u64,
13442 flexibility: ::fidl_next::protocol::Flexibility,
13443 body: ::fidl_next::Body<___T>,
13444 ) -> ::core::result::Result<
13445 (),
13446 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13447 > {
13448 match ordinal {
13449 926684461087488948 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
13450 Ok(decoded) => {
13451 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
13452 Ok(())
13453 }
13454 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13455 ordinal: 926684461087488948,
13456 error,
13457 }),
13458 },
13459
13460 ordinal => {
13461 handler.on_unknown_interaction(ordinal).await;
13462 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13463 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13464 } else {
13465 Ok(())
13466 }
13467 }
13468 }
13469 }
13470
13471 async fn on_two_way(
13472 handler: &mut ___H,
13473 ordinal: u64,
13474 flexibility: ::fidl_next::protocol::Flexibility,
13475 body: ::fidl_next::Body<___T>,
13476 responder: ::fidl_next::protocol::Responder<___T>,
13477 ) -> ::core::result::Result<
13478 (),
13479 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13480 > {
13481 match ordinal {
13482 ordinal => {
13483 handler.on_unknown_interaction(ordinal).await;
13484 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13485 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13486 } else {
13487 responder
13488 .respond(
13489 ordinal,
13490 flexibility,
13491 ::fidl_next::Flexible::<()>::FrameworkErr(
13492 ::fidl_next::FrameworkError::UnknownMethod,
13493 ),
13494 )
13495 .expect("encoding a framework error should never fail")
13496 .await?;
13497 Ok(())
13498 }
13499 }
13500 }
13501 }
13502}
13503
13504#[derive(PartialEq, Debug)]
13506pub struct DirectoryRouter;
13507
13508impl ::fidl_next::Discoverable for DirectoryRouter {
13509 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
13510}
13511
13512#[cfg(target_os = "fuchsia")]
13513impl ::fidl_next::HasTransport for DirectoryRouter {
13514 type Transport = ::fidl_next::fuchsia::zx::Channel;
13515}
13516
13517pub mod directory_router {
13518 pub mod prelude {
13519 pub use crate::{
13520 DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
13521 directory_router,
13522 };
13523
13524 pub use crate::natural::DirectoryRouterRouteResponse;
13525
13526 pub use crate::natural::RouteRequest;
13527
13528 pub use crate::natural::RouterError;
13529 }
13530
13531 pub struct Route;
13532
13533 impl ::fidl_next::Method for Route {
13534 const ORDINAL: u64 = 7510716014181158689;
13535 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13536 ::fidl_next::protocol::Flexibility::Flexible;
13537
13538 type Protocol = crate::DirectoryRouter;
13539
13540 type Request = crate::wire::RouteRequest<'static>;
13541 }
13542
13543 impl ::fidl_next::TwoWayMethod for Route {
13544 type Response = ::fidl_next::wire::FlexibleResult<
13545 'static,
13546 crate::wire::DirectoryRouterRouteResponse,
13547 crate::wire::RouterError,
13548 >;
13549 }
13550
13551 impl<___R> ::fidl_next::Respond<___R> for Route {
13552 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
13553
13554 fn respond(response: ___R) -> Self::Output {
13555 ::fidl_next::FlexibleResult::Ok(response)
13556 }
13557 }
13558
13559 impl<___R> ::fidl_next::RespondErr<___R> for Route {
13560 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
13561
13562 fn respond_err(response: ___R) -> Self::Output {
13563 ::fidl_next::FlexibleResult::Err(response)
13564 }
13565 }
13566
13567 mod ___detail {
13568 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
13569 where
13570 ___T: ::fidl_next::Transport,
13571 {
13572 type Client = DirectoryRouterClient<___T>;
13573 type Server = DirectoryRouterServer<___T>;
13574 }
13575
13576 #[repr(transparent)]
13578 pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
13579 #[allow(dead_code)]
13580 client: ::fidl_next::protocol::Client<___T>,
13581 }
13582
13583 impl<___T> DirectoryRouterClient<___T>
13584 where
13585 ___T: ::fidl_next::Transport,
13586 {
13587 pub fn route_with<___R>(
13588 &self,
13589 request: ___R,
13590 ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13591 where
13592 ___R: ::fidl_next::Encode<
13593 crate::wire::RouteRequest<'static>,
13594 <___T as ::fidl_next::Transport>::SendBuffer,
13595 >,
13596 {
13597 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13598 7510716014181158689,
13599 <super::Route as ::fidl_next::Method>::FLEXIBILITY,
13600 request,
13601 ))
13602 }
13603 }
13604
13605 #[repr(transparent)]
13607 pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
13608 server: ::fidl_next::protocol::Server<___T>,
13609 }
13610
13611 impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
13612 }
13613}
13614
13615pub trait DirectoryRouterClientHandler<
13619 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13620 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13621>
13622{
13623 fn on_unknown_interaction(
13624 &mut self,
13625 ordinal: u64,
13626 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13627 ::core::future::ready(())
13628 }
13629}
13630
13631impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
13632where
13633 ___T: ::fidl_next::Transport,
13634{
13635 async fn on_unknown_interaction(&mut self, _: u64) {}
13636}
13637
13638impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
13639where
13640 ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
13641 ___T: ::fidl_next::Transport,
13642{
13643 async fn on_event(
13644 handler: &mut ___H,
13645 ordinal: u64,
13646 flexibility: ::fidl_next::protocol::Flexibility,
13647 body: ::fidl_next::Body<___T>,
13648 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13649 match ordinal {
13650 ordinal => {
13651 handler.on_unknown_interaction(ordinal).await;
13652 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13653 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13654 } else {
13655 Ok(())
13656 }
13657 }
13658 }
13659 }
13660}
13661
13662pub trait DirectoryRouterServerHandler<
13666 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13667 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13668>
13669{
13670 fn route(
13671 &mut self,
13672
13673 request: ::fidl_next::Request<directory_router::Route, ___T>,
13674
13675 responder: ::fidl_next::Responder<directory_router::Route, ___T>,
13676 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13677
13678 fn on_unknown_interaction(
13679 &mut self,
13680 ordinal: u64,
13681 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13682 ::core::future::ready(())
13683 }
13684}
13685
13686impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
13687where
13688 ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
13689 ___T: ::fidl_next::Transport,
13690 for<'de> crate::wire::RouteRequest<'de>: ::fidl_next::Decode<
13691 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13692 Constraint = (),
13693 >,
13694{
13695 async fn on_one_way(
13696 handler: &mut ___H,
13697 ordinal: u64,
13698 flexibility: ::fidl_next::protocol::Flexibility,
13699 body: ::fidl_next::Body<___T>,
13700 ) -> ::core::result::Result<
13701 (),
13702 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13703 > {
13704 match ordinal {
13705 ordinal => {
13706 handler.on_unknown_interaction(ordinal).await;
13707 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13708 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13709 } else {
13710 Ok(())
13711 }
13712 }
13713 }
13714 }
13715
13716 async fn on_two_way(
13717 handler: &mut ___H,
13718 ordinal: u64,
13719 flexibility: ::fidl_next::protocol::Flexibility,
13720 body: ::fidl_next::Body<___T>,
13721 responder: ::fidl_next::protocol::Responder<___T>,
13722 ) -> ::core::result::Result<
13723 (),
13724 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13725 > {
13726 match ordinal {
13727 7510716014181158689 => {
13728 let responder = ::fidl_next::Responder::from_untyped(responder);
13729
13730 match ::fidl_next::AsDecoderExt::into_decoded(body) {
13731 Ok(decoded) => {
13732 handler.route(::fidl_next::Request::from_decoded(decoded), responder).await;
13733 Ok(())
13734 }
13735 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13736 ordinal: 7510716014181158689,
13737 error,
13738 }),
13739 }
13740 }
13741
13742 ordinal => {
13743 handler.on_unknown_interaction(ordinal).await;
13744 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13745 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13746 } else {
13747 responder
13748 .respond(
13749 ordinal,
13750 flexibility,
13751 ::fidl_next::Flexible::<()>::FrameworkErr(
13752 ::fidl_next::FrameworkError::UnknownMethod,
13753 ),
13754 )
13755 .expect("encoding a framework error should never fail")
13756 .await?;
13757 Ok(())
13758 }
13759 }
13760 }
13761 }
13762}
13763
13764#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
13766#[derive(PartialEq, Debug)]
13767pub struct Receiver;
13768
13769impl ::fidl_next::Discoverable for Receiver {
13770 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
13771}
13772
13773#[cfg(target_os = "fuchsia")]
13774impl ::fidl_next::HasTransport for Receiver {
13775 type Transport = ::fidl_next::fuchsia::zx::Channel;
13776}
13777
13778pub mod receiver {
13779 pub mod prelude {
13780 pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
13781
13782 pub use crate::natural::ProtocolPayload;
13783 }
13784
13785 pub struct Receive;
13786
13787 impl ::fidl_next::Method for Receive {
13788 const ORDINAL: u64 = 340832707723008660;
13789 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13790 ::fidl_next::protocol::Flexibility::Flexible;
13791
13792 type Protocol = crate::Receiver;
13793
13794 type Request = crate::wire::ProtocolPayload;
13795 }
13796
13797 mod ___detail {
13798 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
13799 where
13800 ___T: ::fidl_next::Transport,
13801 {
13802 type Client = ReceiverClient<___T>;
13803 type Server = ReceiverServer<___T>;
13804 }
13805
13806 #[repr(transparent)]
13808 pub struct ReceiverClient<___T: ::fidl_next::Transport> {
13809 #[allow(dead_code)]
13810 client: ::fidl_next::protocol::Client<___T>,
13811 }
13812
13813 impl<___T> ReceiverClient<___T>
13814 where
13815 ___T: ::fidl_next::Transport,
13816 {
13817 #[doc = " Sends a channel to this receiver.\n"]
13818 pub fn receive(
13819 &self,
13820
13821 channel: impl ::fidl_next::Encode<
13822 ::fidl_next::wire::fuchsia::Channel,
13823 <___T as ::fidl_next::Transport>::SendBuffer,
13824 >,
13825 ) -> ::fidl_next::SendFuture<'_, ___T>
13826 where
13827 <___T as ::fidl_next::Transport>::SendBuffer:
13828 ::fidl_next::encoder::InternalHandleEncoder,
13829 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13830 {
13831 self.receive_with(crate::generic::ProtocolPayload { channel })
13832 }
13833
13834 #[doc = " Sends a channel to this receiver.\n"]
13835 pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
13836 where
13837 ___R: ::fidl_next::Encode<
13838 crate::wire::ProtocolPayload,
13839 <___T as ::fidl_next::Transport>::SendBuffer,
13840 >,
13841 {
13842 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
13843 340832707723008660,
13844 <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
13845 request,
13846 ))
13847 }
13848 }
13849
13850 #[repr(transparent)]
13852 pub struct ReceiverServer<___T: ::fidl_next::Transport> {
13853 server: ::fidl_next::protocol::Server<___T>,
13854 }
13855
13856 impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
13857 }
13858}
13859
13860pub trait ReceiverClientHandler<
13864 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13865 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13866>
13867{
13868 fn on_unknown_interaction(
13869 &mut self,
13870 ordinal: u64,
13871 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13872 ::core::future::ready(())
13873 }
13874}
13875
13876impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
13877where
13878 ___T: ::fidl_next::Transport,
13879{
13880 async fn on_unknown_interaction(&mut self, _: u64) {}
13881}
13882
13883impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
13884where
13885 ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
13886 ___T: ::fidl_next::Transport,
13887{
13888 async fn on_event(
13889 handler: &mut ___H,
13890 ordinal: u64,
13891 flexibility: ::fidl_next::protocol::Flexibility,
13892 body: ::fidl_next::Body<___T>,
13893 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13894 match ordinal {
13895 ordinal => {
13896 handler.on_unknown_interaction(ordinal).await;
13897 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13898 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13899 } else {
13900 Ok(())
13901 }
13902 }
13903 }
13904 }
13905}
13906
13907pub trait ReceiverServerHandler<
13911 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13912 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13913>
13914{
13915 #[doc = " Sends a channel to this receiver.\n"]
13916 fn receive(
13917 &mut self,
13918
13919 request: ::fidl_next::Request<receiver::Receive, ___T>,
13920 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13921
13922 fn on_unknown_interaction(
13923 &mut self,
13924 ordinal: u64,
13925 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
13926 ::core::future::ready(())
13927 }
13928}
13929
13930impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
13931where
13932 ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
13933 ___T: ::fidl_next::Transport,
13934 for<'de> crate::wire::ProtocolPayload: ::fidl_next::Decode<
13935 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13936 Constraint = (),
13937 >,
13938{
13939 async fn on_one_way(
13940 handler: &mut ___H,
13941 ordinal: u64,
13942 flexibility: ::fidl_next::protocol::Flexibility,
13943 body: ::fidl_next::Body<___T>,
13944 ) -> ::core::result::Result<
13945 (),
13946 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13947 > {
13948 match ordinal {
13949 340832707723008660 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
13950 Ok(decoded) => {
13951 handler.receive(::fidl_next::Request::from_decoded(decoded)).await;
13952 Ok(())
13953 }
13954 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13955 ordinal: 340832707723008660,
13956 error,
13957 }),
13958 },
13959
13960 ordinal => {
13961 handler.on_unknown_interaction(ordinal).await;
13962 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13963 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13964 } else {
13965 Ok(())
13966 }
13967 }
13968 }
13969 }
13970
13971 async fn on_two_way(
13972 handler: &mut ___H,
13973 ordinal: u64,
13974 flexibility: ::fidl_next::protocol::Flexibility,
13975 body: ::fidl_next::Body<___T>,
13976 responder: ::fidl_next::protocol::Responder<___T>,
13977 ) -> ::core::result::Result<
13978 (),
13979 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13980 > {
13981 match ordinal {
13982 ordinal => {
13983 handler.on_unknown_interaction(ordinal).await;
13984 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
13985 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
13986 } else {
13987 responder
13988 .respond(
13989 ordinal,
13990 flexibility,
13991 ::fidl_next::Flexible::<()>::FrameworkErr(
13992 ::fidl_next::FrameworkError::UnknownMethod,
13993 ),
13994 )
13995 .expect("encoding a framework error should never fail")
13996 .await?;
13997 Ok(())
13998 }
13999 }
14000 }
14001 }
14002}
14003
14004pub use fidl_next_common_fuchsia_component_sandbox::*;
14005
14006pub mod compat {
14008
14009 pub use fidl_next_common_fuchsia_component_sandbox::compat::*;
14010
14011 impl ::fidl_next::CompatFrom<crate::DirConnector>
14012 for ::fidl_fuchsia_component_sandbox::DirConnector
14013 {
14014 #[inline]
14015 fn compat_from(value: crate::DirConnector) -> Self {
14016 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14017 }
14018 }
14019
14020 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
14021 for crate::DirConnector
14022 {
14023 #[inline]
14024 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
14025 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14026 }
14027 }
14028
14029 impl ::fidl_next::CompatFrom<crate::AggregateSource>
14030 for ::fidl_fuchsia_component_sandbox::AggregateSource
14031 {
14032 fn compat_from(value: crate::AggregateSource) -> Self {
14033 Self {
14034 dir_connector: ::fidl_next::CompatFrom::compat_from(value.dir_connector),
14035
14036 source_instance_filter: ::fidl_next::CompatFrom::compat_from(
14037 value.source_instance_filter,
14038 ),
14039
14040 renamed_instances: ::fidl_next::CompatFrom::compat_from(value.renamed_instances),
14041
14042 __source_breaking: ::fidl::marker::SourceBreaking,
14043 }
14044 }
14045 }
14046
14047 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::AggregateSource>
14048 for crate::AggregateSource
14049 {
14050 fn compat_from(value: ::fidl_fuchsia_component_sandbox::AggregateSource) -> Self {
14051 Self {
14052 dir_connector: ::fidl_next::CompatFrom::compat_from(value.dir_connector),
14053
14054 source_instance_filter: ::fidl_next::CompatFrom::compat_from(
14055 value.source_instance_filter,
14056 ),
14057
14058 renamed_instances: ::fidl_next::CompatFrom::compat_from(value.renamed_instances),
14059 }
14060 }
14061 }
14062
14063 impl ::fidl_next::CompatFrom<crate::DictionaryRef>
14064 for ::fidl_fuchsia_component_sandbox::DictionaryRef
14065 {
14066 #[inline]
14067 fn compat_from(value: crate::DictionaryRef) -> Self {
14068 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14069 }
14070 }
14071
14072 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
14073 for crate::DictionaryRef
14074 {
14075 #[inline]
14076 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
14077 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14078 }
14079 }
14080
14081 impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
14082 #[inline]
14083 fn compat_from(value: crate::Connector) -> Self {
14084 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14085 }
14086 }
14087
14088 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
14089 #[inline]
14090 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
14091 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14092 }
14093 }
14094
14095 impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
14096 #[inline]
14097 fn compat_from(value: crate::DirEntry) -> Self {
14098 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14099 }
14100 }
14101
14102 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
14103 #[inline]
14104 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
14105 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14106 }
14107 }
14108
14109 impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
14110 fn compat_from(value: crate::Capability) -> Self {
14111 match value {
14112 crate::Capability::Unit(value) => {
14113 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
14114 }
14115
14116 crate::Capability::Handle(value) => {
14117 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
14118 }
14119
14120 crate::Capability::Data(value) => {
14121 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14122 }
14123
14124 crate::Capability::Dictionary(value) => {
14125 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
14126 }
14127
14128 crate::Capability::Connector(value) => {
14129 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
14130 }
14131
14132 crate::Capability::DirConnector(value) => {
14133 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
14134 }
14135
14136 crate::Capability::Directory(value) => {
14137 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
14138 }
14139
14140 crate::Capability::DirEntry(value) => {
14141 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
14142 }
14143
14144 crate::Capability::ConnectorRouter(value) => {
14145 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
14146 }
14147
14148 crate::Capability::DictionaryRouter(value) => {
14149 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
14150 }
14151
14152 crate::Capability::DirEntryRouter(value) => {
14153 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
14154 }
14155
14156 crate::Capability::DataRouter(value) => {
14157 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
14158 }
14159
14160 crate::Capability::DirConnectorRouter(value) => {
14161 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
14162 }
14163
14164 crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
14165 Self::__SourceBreaking { unknown_ordinal }
14166 }
14167 }
14168 }
14169 }
14170
14171 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
14172 fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
14173 match value {
14174 ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
14175 Self::Unit(::fidl_next::CompatFrom::compat_from(value))
14176 }
14177
14178 ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
14179 Self::Handle(::fidl_next::CompatFrom::compat_from(value))
14180 }
14181
14182 ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
14183 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14184 }
14185
14186 ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
14187 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
14188 }
14189
14190 ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
14191 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
14192 }
14193
14194 ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
14195 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
14196 }
14197
14198 ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
14199 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
14200 }
14201
14202 ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
14203 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
14204 }
14205
14206 ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
14207 Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
14208 }
14209
14210 ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
14211 Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
14212 }
14213
14214 ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
14215 Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
14216 }
14217
14218 ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
14219 Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
14220 }
14221
14222 ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
14223 Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
14224 }
14225
14226 ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
14227 unknown_ordinal,
14228 } => Self::UnknownOrdinal_(unknown_ordinal),
14229 }
14230 }
14231 }
14232
14233 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
14234 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
14235 {
14236 #[inline]
14237 fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
14238 Self {
14239 id: ::fidl_next::CompatFrom::compat_from(value.id),
14240
14241 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
14242 }
14243 }
14244 }
14245
14246 impl
14247 ::fidl_next::CompatFrom<
14248 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
14249 > for crate::CapabilityStoreConnectorCreateRequest
14250 {
14251 #[inline]
14252 fn compat_from(
14253 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
14254 ) -> Self {
14255 Self {
14256 id: ::fidl_next::CompatFrom::compat_from(value.id),
14257
14258 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
14259 }
14260 }
14261 }
14262
14263 impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
14264 for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
14265 {
14266 #[inline]
14267 fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
14268 Self {
14269 id: ::fidl_next::CompatFrom::compat_from(value.id),
14270
14271 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14272 }
14273 }
14274 }
14275
14276 impl
14277 ::fidl_next::CompatFrom<
14278 ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
14279 > for crate::CapabilityStoreConnectorOpenRequest
14280 {
14281 #[inline]
14282 fn compat_from(
14283 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
14284 ) -> Self {
14285 Self {
14286 id: ::fidl_next::CompatFrom::compat_from(value.id),
14287
14288 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14289 }
14290 }
14291 }
14292
14293 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
14294 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
14295 {
14296 #[inline]
14297 fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
14298 Self {
14299 id: ::fidl_next::CompatFrom::compat_from(value.id),
14300
14301 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
14302 }
14303 }
14304 }
14305
14306 impl
14307 ::fidl_next::CompatFrom<
14308 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
14309 > for crate::CapabilityStoreDirConnectorCreateRequest
14310 {
14311 #[inline]
14312 fn compat_from(
14313 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
14314 ) -> Self {
14315 Self {
14316 id: ::fidl_next::CompatFrom::compat_from(value.id),
14317
14318 receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
14319 }
14320 }
14321 }
14322
14323 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
14324 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
14325 {
14326 #[inline]
14327 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
14328 Self {
14329 id: ::fidl_next::CompatFrom::compat_from(value.id),
14330
14331 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
14332 }
14333 }
14334 }
14335
14336 impl
14337 ::fidl_next::CompatFrom<
14338 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
14339 > for crate::CapabilityStoreDictionaryLegacyImportRequest
14340 {
14341 #[inline]
14342 fn compat_from(
14343 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
14344 ) -> Self {
14345 Self {
14346 id: ::fidl_next::CompatFrom::compat_from(value.id),
14347
14348 client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
14349 }
14350 }
14351 }
14352
14353 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
14354 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
14355 {
14356 #[inline]
14357 fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
14358 Self {
14359 id: ::fidl_next::CompatFrom::compat_from(value.id),
14360
14361 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14362 }
14363 }
14364 }
14365
14366 impl
14367 ::fidl_next::CompatFrom<
14368 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
14369 > for crate::CapabilityStoreDictionaryLegacyExportRequest
14370 {
14371 #[inline]
14372 fn compat_from(
14373 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
14374 ) -> Self {
14375 Self {
14376 id: ::fidl_next::CompatFrom::compat_from(value.id),
14377
14378 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14379 }
14380 }
14381 }
14382
14383 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
14384 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
14385 {
14386 #[inline]
14387 fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
14388 Self {
14389 id: ::fidl_next::CompatFrom::compat_from(value.id),
14390
14391 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14392 }
14393 }
14394 }
14395
14396 impl
14397 ::fidl_next::CompatFrom<
14398 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
14399 > for crate::CapabilityStoreDictionaryKeysRequest
14400 {
14401 #[inline]
14402 fn compat_from(
14403 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
14404 ) -> Self {
14405 Self {
14406 id: ::fidl_next::CompatFrom::compat_from(value.id),
14407
14408 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14409 }
14410 }
14411 }
14412
14413 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
14414 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
14415 {
14416 #[inline]
14417 fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
14418 Self {
14419 id: ::fidl_next::CompatFrom::compat_from(value.id),
14420
14421 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14422 }
14423 }
14424 }
14425
14426 impl
14427 ::fidl_next::CompatFrom<
14428 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
14429 > for crate::CapabilityStoreDictionaryEnumerateRequest
14430 {
14431 #[inline]
14432 fn compat_from(
14433 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
14434 ) -> Self {
14435 Self {
14436 id: ::fidl_next::CompatFrom::compat_from(value.id),
14437
14438 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14439 }
14440 }
14441 }
14442
14443 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
14444 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
14445 {
14446 #[inline]
14447 fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
14448 Self {
14449 id: ::fidl_next::CompatFrom::compat_from(value.id),
14450
14451 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14452 }
14453 }
14454 }
14455
14456 impl
14457 ::fidl_next::CompatFrom<
14458 ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
14459 > for crate::CapabilityStoreDictionaryDrainRequest
14460 {
14461 #[inline]
14462 fn compat_from(
14463 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
14464 ) -> Self {
14465 Self {
14466 id: ::fidl_next::CompatFrom::compat_from(value.id),
14467
14468 iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
14469 }
14470 }
14471 }
14472
14473 impl ::fidl_next::CompatFrom<crate::CapabilityStoreCreateServiceAggregateRequest>
14474 for ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest
14475 {
14476 #[inline]
14477 fn compat_from(value: crate::CapabilityStoreCreateServiceAggregateRequest) -> Self {
14478 Self { sources: ::fidl_next::CompatFrom::compat_from(value.sources) }
14479 }
14480 }
14481
14482 impl
14483 ::fidl_next::CompatFrom<
14484 ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest,
14485 > for crate::CapabilityStoreCreateServiceAggregateRequest
14486 {
14487 #[inline]
14488 fn compat_from(
14489 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateRequest,
14490 ) -> Self {
14491 Self { sources: ::fidl_next::CompatFrom::compat_from(value.sources) }
14492 }
14493 }
14494
14495 impl ::fidl_next::CompatFrom<crate::CapabilityStoreCreateServiceAggregateResponse>
14496 for ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse
14497 {
14498 #[inline]
14499 fn compat_from(value: crate::CapabilityStoreCreateServiceAggregateResponse) -> Self {
14500 Self {
14501 aggregate_dir_connector: ::fidl_next::CompatFrom::compat_from(
14502 value.aggregate_dir_connector,
14503 ),
14504 }
14505 }
14506 }
14507
14508 impl
14509 ::fidl_next::CompatFrom<
14510 ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse,
14511 > for crate::CapabilityStoreCreateServiceAggregateResponse
14512 {
14513 #[inline]
14514 fn compat_from(
14515 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreCreateServiceAggregateResponse,
14516 ) -> Self {
14517 Self {
14518 aggregate_dir_connector: ::fidl_next::CompatFrom::compat_from(
14519 value.aggregate_dir_connector,
14520 ),
14521 }
14522 }
14523 }
14524
14525 impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
14526 for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
14527 {
14528 #[inline]
14529 fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
14530 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
14531 }
14532 }
14533
14534 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
14535 for crate::CapabilityStoreExportResponse
14536 {
14537 #[inline]
14538 fn compat_from(
14539 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
14540 ) -> Self {
14541 Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
14542 }
14543 }
14544
14545 impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
14546 for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
14547 {
14548 #[inline]
14549 fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
14550 Self {
14551 id: ::fidl_next::CompatFrom::compat_from(value.id),
14552
14553 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
14554 }
14555 }
14556 }
14557
14558 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
14559 for crate::CapabilityStoreImportRequest
14560 {
14561 #[inline]
14562 fn compat_from(
14563 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
14564 ) -> Self {
14565 Self {
14566 id: ::fidl_next::CompatFrom::compat_from(value.id),
14567
14568 capability: ::fidl_next::CompatFrom::compat_from(value.capability),
14569 }
14570 }
14571 }
14572
14573 impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
14574 for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
14575 {
14576 fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
14577 Self {
14578 id: ::fidl_next::CompatFrom::compat_from(value.id),
14579
14580 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14581
14582 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14583
14584 path: ::fidl_next::CompatFrom::compat_from(value.path),
14585
14586 __source_breaking: ::fidl::marker::SourceBreaking,
14587 }
14588 }
14589 }
14590
14591 impl
14592 ::fidl_next::CompatFrom<
14593 ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
14594 > for crate::CapabilityStoreDirConnectorOpenRequest
14595 {
14596 fn compat_from(
14597 value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
14598 ) -> Self {
14599 Self {
14600 id: ::fidl_next::CompatFrom::compat_from(value.id),
14601
14602 server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
14603
14604 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
14605
14606 path: ::fidl_next::CompatFrom::compat_from(value.path),
14607 }
14608 }
14609 }
14610
14611 #[cfg(target_os = "fuchsia")]
14612 pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
14615
14616 impl ::fidl_next::CompatFrom<crate::CapabilityStore>
14617 for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
14618 {
14619 fn compat_from(_: crate::CapabilityStore) -> Self {
14620 Self
14621 }
14622 }
14623
14624 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
14625 for crate::CapabilityStore
14626 {
14627 fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
14628 Self
14629 }
14630 }
14631
14632 #[cfg(target_os = "fuchsia")]
14633
14634 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
14635 for crate::CapabilityStore
14636 {
14637 fn client_compat_from(
14638 proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
14639 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14640 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14641 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14642 ::fidl_next::ClientDispatcher::new(client_end)
14643 }
14644 }
14645
14646 impl ::fidl_next::CompatFrom<crate::InstanceToken>
14647 for ::fidl_fuchsia_component_sandbox::InstanceToken
14648 {
14649 #[inline]
14650 fn compat_from(value: crate::InstanceToken) -> Self {
14651 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14652 }
14653 }
14654
14655 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
14656 for crate::InstanceToken
14657 {
14658 #[inline]
14659 fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
14660 Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
14661 }
14662 }
14663
14664 impl ::fidl_next::CompatFrom<crate::RouteRequest>
14665 for ::fidl_fuchsia_component_sandbox::RouteRequest
14666 {
14667 fn compat_from(value: crate::RouteRequest) -> Self {
14668 Self {
14669 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
14670
14671 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
14672
14673 __source_breaking: ::fidl::marker::SourceBreaking,
14674 }
14675 }
14676 }
14677
14678 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
14679 for crate::RouteRequest
14680 {
14681 fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
14682 Self {
14683 requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
14684
14685 metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
14686 }
14687 }
14688 }
14689
14690 impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
14691 for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
14692 {
14693 fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
14694 match value {
14695 crate::ConnectorRouterRouteResponse::Connector(value) => {
14696 Self::Connector(::fidl_next::CompatFrom::compat_from(value))
14697 }
14698
14699 crate::ConnectorRouterRouteResponse::Unavailable(value) => {
14700 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14701 }
14702 }
14703 }
14704 }
14705
14706 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
14707 for crate::ConnectorRouterRouteResponse
14708 {
14709 fn compat_from(
14710 value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
14711 ) -> Self {
14712 match value {
14713 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
14714 value,
14715 ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
14716
14717 ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
14718 value,
14719 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
14720 }
14721 }
14722 }
14723
14724 #[cfg(target_os = "fuchsia")]
14725 pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
14728
14729 impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
14730 for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
14731 {
14732 fn compat_from(_: crate::ConnectorRouter) -> Self {
14733 Self
14734 }
14735 }
14736
14737 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
14738 for crate::ConnectorRouter
14739 {
14740 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
14741 Self
14742 }
14743 }
14744
14745 #[cfg(target_os = "fuchsia")]
14746
14747 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
14748 for crate::ConnectorRouter
14749 {
14750 fn client_compat_from(
14751 proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
14752 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14753 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14754 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14755 ::fidl_next::ClientDispatcher::new(client_end)
14756 }
14757 }
14758
14759 impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
14760 for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
14761 {
14762 fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
14763 match value {
14764 crate::DataRouterRouteResponse::Data(value) => {
14765 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14766 }
14767
14768 crate::DataRouterRouteResponse::Unavailable(value) => {
14769 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14770 }
14771 }
14772 }
14773 }
14774
14775 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
14776 for crate::DataRouterRouteResponse
14777 {
14778 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
14779 match value {
14780 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
14781 Self::Data(::fidl_next::CompatFrom::compat_from(value))
14782 }
14783
14784 ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
14785 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
14786 }
14787 }
14788 }
14789 }
14790
14791 #[cfg(target_os = "fuchsia")]
14792 pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
14795
14796 impl ::fidl_next::CompatFrom<crate::DataRouter>
14797 for ::fidl_fuchsia_component_sandbox::DataRouterMarker
14798 {
14799 fn compat_from(_: crate::DataRouter) -> Self {
14800 Self
14801 }
14802 }
14803
14804 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
14805 for crate::DataRouter
14806 {
14807 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
14808 Self
14809 }
14810 }
14811
14812 #[cfg(target_os = "fuchsia")]
14813
14814 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
14815 for crate::DataRouter
14816 {
14817 fn client_compat_from(
14818 proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
14819 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14820 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14821 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14822 ::fidl_next::ClientDispatcher::new(client_end)
14823 }
14824 }
14825
14826 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
14827 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
14828 {
14829 #[inline]
14830 fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
14831 Self {
14832 items: ::fidl_next::CompatFrom::compat_from(value.items),
14833
14834 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14835 }
14836 }
14837 }
14838
14839 impl
14840 ::fidl_next::CompatFrom<
14841 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
14842 > for crate::DictionaryDrainIteratorGetNextResponse
14843 {
14844 #[inline]
14845 fn compat_from(
14846 value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
14847 ) -> Self {
14848 Self {
14849 items: ::fidl_next::CompatFrom::compat_from(value.items),
14850
14851 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14852 }
14853 }
14854 }
14855
14856 #[cfg(target_os = "fuchsia")]
14857 pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
14860
14861 impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
14862 for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
14863 {
14864 fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
14865 Self
14866 }
14867 }
14868
14869 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
14870 for crate::DictionaryDrainIterator
14871 {
14872 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
14873 Self
14874 }
14875 }
14876
14877 #[cfg(target_os = "fuchsia")]
14878
14879 impl
14880 ::fidl_next::ClientCompatFrom<
14881 ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
14882 > for crate::DictionaryDrainIterator
14883 {
14884 fn client_compat_from(
14885 proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
14886 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14887 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14888 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14889 ::fidl_next::ClientDispatcher::new(client_end)
14890 }
14891 }
14892
14893 impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
14894 for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
14895 {
14896 #[inline]
14897 fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
14898 Self {
14899 key: ::fidl_next::CompatFrom::compat_from(value.key),
14900
14901 value: ::fidl_next::CompatFrom::compat_from(value.value),
14902 }
14903 }
14904 }
14905
14906 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
14907 for crate::DictionaryOptionalItem
14908 {
14909 #[inline]
14910 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
14911 Self {
14912 key: ::fidl_next::CompatFrom::compat_from(value.key),
14913
14914 value: ::fidl_next::CompatFrom::compat_from(value.value),
14915 }
14916 }
14917 }
14918
14919 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
14920 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
14921 {
14922 #[inline]
14923 fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
14924 Self {
14925 items: ::fidl_next::CompatFrom::compat_from(value.items),
14926
14927 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14928 }
14929 }
14930 }
14931
14932 impl
14933 ::fidl_next::CompatFrom<
14934 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
14935 > for crate::DictionaryEnumerateIteratorGetNextResponse
14936 {
14937 #[inline]
14938 fn compat_from(
14939 value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
14940 ) -> Self {
14941 Self {
14942 items: ::fidl_next::CompatFrom::compat_from(value.items),
14943
14944 end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
14945 }
14946 }
14947 }
14948
14949 #[cfg(target_os = "fuchsia")]
14950 pub type DictionaryEnumerateIteratorProxy =
14953 ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
14954
14955 impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
14956 for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
14957 {
14958 fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
14959 Self
14960 }
14961 }
14962
14963 impl
14964 ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
14965 for crate::DictionaryEnumerateIterator
14966 {
14967 fn compat_from(
14968 _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
14969 ) -> Self {
14970 Self
14971 }
14972 }
14973
14974 #[cfg(target_os = "fuchsia")]
14975
14976 impl
14977 ::fidl_next::ClientCompatFrom<
14978 ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
14979 > for crate::DictionaryEnumerateIterator
14980 {
14981 fn client_compat_from(
14982 proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
14983 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
14984 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
14985 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
14986 ::fidl_next::ClientDispatcher::new(client_end)
14987 }
14988 }
14989
14990 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
14991 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
14992 {
14993 #[inline]
14994 fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
14995 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
14996 }
14997 }
14998
14999 impl
15000 ::fidl_next::CompatFrom<
15001 ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
15002 > for crate::DictionaryKeysIteratorGetNextResponse
15003 {
15004 #[inline]
15005 fn compat_from(
15006 value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
15007 ) -> Self {
15008 Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
15009 }
15010 }
15011
15012 #[cfg(target_os = "fuchsia")]
15013 pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
15016
15017 impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
15018 for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
15019 {
15020 fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
15021 Self
15022 }
15023 }
15024
15025 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
15026 for crate::DictionaryKeysIterator
15027 {
15028 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
15029 Self
15030 }
15031 }
15032
15033 #[cfg(target_os = "fuchsia")]
15034
15035 impl
15036 ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
15037 for crate::DictionaryKeysIterator
15038 {
15039 fn client_compat_from(
15040 proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
15041 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15042 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15043 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15044 ::fidl_next::ClientDispatcher::new(client_end)
15045 }
15046 }
15047
15048 impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
15049 for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
15050 {
15051 fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
15052 match value {
15053 crate::DictionaryRouterRouteResponse::Dictionary(value) => {
15054 Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
15055 }
15056
15057 crate::DictionaryRouterRouteResponse::Unavailable(value) => {
15058 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
15059 }
15060 }
15061 }
15062 }
15063
15064 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
15065 for crate::DictionaryRouterRouteResponse
15066 {
15067 fn compat_from(
15068 value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
15069 ) -> Self {
15070 match value {
15071 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
15072 value,
15073 ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
15074
15075 ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
15076 value,
15077 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
15078 }
15079 }
15080 }
15081
15082 #[cfg(target_os = "fuchsia")]
15083 pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
15086
15087 impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
15088 for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
15089 {
15090 fn compat_from(_: crate::DictionaryRouter) -> Self {
15091 Self
15092 }
15093 }
15094
15095 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
15096 for crate::DictionaryRouter
15097 {
15098 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
15099 Self
15100 }
15101 }
15102
15103 #[cfg(target_os = "fuchsia")]
15104
15105 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
15106 for crate::DictionaryRouter
15107 {
15108 fn client_compat_from(
15109 proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
15110 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15111 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15112 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15113 ::fidl_next::ClientDispatcher::new(client_end)
15114 }
15115 }
15116
15117 impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
15118 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
15119 {
15120 fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
15121 match value {
15122 crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
15123 Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
15124 }
15125
15126 crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
15127 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
15128 }
15129 }
15130 }
15131 }
15132
15133 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
15134 for crate::DirConnectorRouterRouteResponse
15135 {
15136 fn compat_from(
15137 value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
15138 ) -> Self {
15139 match value {
15140 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
15141 value,
15142 ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
15143
15144 ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
15145 value,
15146 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
15147 }
15148 }
15149 }
15150
15151 #[cfg(target_os = "fuchsia")]
15152 pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
15155
15156 impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
15157 for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
15158 {
15159 fn compat_from(_: crate::DirConnectorRouter) -> Self {
15160 Self
15161 }
15162 }
15163
15164 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
15165 for crate::DirConnectorRouter
15166 {
15167 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
15168 Self
15169 }
15170 }
15171
15172 #[cfg(target_os = "fuchsia")]
15173
15174 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
15175 for crate::DirConnectorRouter
15176 {
15177 fn client_compat_from(
15178 proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
15179 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15180 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15181 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15182 ::fidl_next::ClientDispatcher::new(client_end)
15183 }
15184 }
15185
15186 impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
15187 for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
15188 {
15189 fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
15190 match value {
15191 crate::DirEntryRouterRouteResponse::DirEntry(value) => {
15192 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15193 }
15194
15195 crate::DirEntryRouterRouteResponse::Unavailable(value) => {
15196 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
15197 }
15198 }
15199 }
15200 }
15201
15202 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
15203 for crate::DirEntryRouterRouteResponse
15204 {
15205 fn compat_from(
15206 value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
15207 ) -> Self {
15208 match value {
15209 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
15210 Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15211 }
15212
15213 ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
15214 value,
15215 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
15216 }
15217 }
15218 }
15219
15220 #[cfg(target_os = "fuchsia")]
15221 pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
15224
15225 impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
15226 for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
15227 {
15228 fn compat_from(_: crate::DirEntryRouter) -> Self {
15229 Self
15230 }
15231 }
15232
15233 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
15234 for crate::DirEntryRouter
15235 {
15236 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
15237 Self
15238 }
15239 }
15240
15241 #[cfg(target_os = "fuchsia")]
15242
15243 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
15244 for crate::DirEntryRouter
15245 {
15246 fn client_compat_from(
15247 proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
15248 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15249 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15250 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15251 ::fidl_next::ClientDispatcher::new(client_end)
15252 }
15253 }
15254
15255 impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
15256 for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
15257 {
15258 fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
15259 Self {
15260 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
15261
15262 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15263
15264 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
15265
15266 __source_breaking: ::fidl::marker::SourceBreaking,
15267 }
15268 }
15269 }
15270
15271 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
15272 for crate::DirReceiverReceiveRequest
15273 {
15274 fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
15275 Self {
15276 channel: ::fidl_next::CompatFrom::compat_from(value.channel),
15277
15278 flags: ::fidl_next::CompatFrom::compat_from(value.flags),
15279
15280 subdir: ::fidl_next::CompatFrom::compat_from(value.subdir),
15281 }
15282 }
15283 }
15284
15285 #[cfg(target_os = "fuchsia")]
15286 pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
15289
15290 impl ::fidl_next::CompatFrom<crate::DirReceiver>
15291 for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
15292 {
15293 fn compat_from(_: crate::DirReceiver) -> Self {
15294 Self
15295 }
15296 }
15297
15298 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
15299 for crate::DirReceiver
15300 {
15301 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
15302 Self
15303 }
15304 }
15305
15306 #[cfg(target_os = "fuchsia")]
15307
15308 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
15309 for crate::DirReceiver
15310 {
15311 fn client_compat_from(
15312 proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
15313 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15314 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15315 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15316 ::fidl_next::ClientDispatcher::new(client_end)
15317 }
15318 }
15319
15320 impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
15321 for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
15322 {
15323 fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
15324 match value {
15325 crate::DirectoryRouterRouteResponse::Directory(value) => {
15326 Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15327 }
15328
15329 crate::DirectoryRouterRouteResponse::Unavailable(value) => {
15330 Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
15331 }
15332 }
15333 }
15334 }
15335
15336 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
15337 for crate::DirectoryRouterRouteResponse
15338 {
15339 fn compat_from(
15340 value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
15341 ) -> Self {
15342 match value {
15343 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
15344 value,
15345 ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
15346
15347 ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
15348 value,
15349 ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
15350 }
15351 }
15352 }
15353
15354 #[cfg(target_os = "fuchsia")]
15355 pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
15358
15359 impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
15360 for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
15361 {
15362 fn compat_from(_: crate::DirectoryRouter) -> Self {
15363 Self
15364 }
15365 }
15366
15367 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
15368 for crate::DirectoryRouter
15369 {
15370 fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
15371 Self
15372 }
15373 }
15374
15375 #[cfg(target_os = "fuchsia")]
15376
15377 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
15378 for crate::DirectoryRouter
15379 {
15380 fn client_compat_from(
15381 proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
15382 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15383 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15384 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15385 ::fidl_next::ClientDispatcher::new(client_end)
15386 }
15387 }
15388
15389 impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
15390 for ::fidl_fuchsia_component_sandbox::ProtocolPayload
15391 {
15392 #[inline]
15393 fn compat_from(value: crate::ProtocolPayload) -> Self {
15394 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
15395 }
15396 }
15397
15398 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
15399 for crate::ProtocolPayload
15400 {
15401 #[inline]
15402 fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
15403 Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
15404 }
15405 }
15406
15407 #[cfg(target_os = "fuchsia")]
15408 pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
15411
15412 impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
15413 fn compat_from(_: crate::Receiver) -> Self {
15414 Self
15415 }
15416 }
15417
15418 impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
15419 fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
15420 Self
15421 }
15422 }
15423
15424 #[cfg(target_os = "fuchsia")]
15425
15426 impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
15427 for crate::Receiver
15428 {
15429 fn client_compat_from(
15430 proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
15431 ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
15432 let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
15433 let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
15434 ::fidl_next::ClientDispatcher::new(client_end)
15435 }
15436 }
15437}