1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " Describes the expected availability of the capability.\n\n Some capabilities may not be present on all system configurations. In those\n cases, the availability will be declared as `OPTIONAL` along the chains of\n exposes/offers/uses, and the capability would be routed from `void` on\n system configurations where it does not make sense to route or provide a\n particular capability (e.g. graphical capabilities on a headless system).\n"]
8 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 #[repr(u32)]
10 pub enum Availability {
11 Required = 1,
12 Optional = 2,
13 SameAsTarget = 3,
14 Transitional = 4,
15 }
16 impl ::core::convert::TryFrom<u32> for Availability {
17 type Error = ::fidl_next::UnknownStrictEnumMemberError;
18 fn try_from(
19 value: u32,
20 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
21 match value {
22 1 => Ok(Self::Required),
23 2 => Ok(Self::Optional),
24 3 => Ok(Self::SameAsTarget),
25 4 => Ok(Self::Transitional),
26
27 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
28 }
29 }
30 }
31
32 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Availability, ___E> for Availability
33 where
34 ___E: ?Sized,
35 {
36 #[inline]
37 fn encode(
38 self,
39 encoder: &mut ___E,
40 out: &mut ::core::mem::MaybeUninit<crate::wire::Availability>,
41 _: (),
42 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
43 ::fidl_next::Encode::encode(&self, encoder, out, ())
44 }
45 }
46
47 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Availability, ___E> for &'a Availability
48 where
49 ___E: ?Sized,
50 {
51 #[inline]
52 fn encode(
53 self,
54 encoder: &mut ___E,
55 out: &mut ::core::mem::MaybeUninit<crate::wire::Availability>,
56 _: (),
57 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
58 ::fidl_next::munge!(let crate::wire::Availability { value } = out);
59 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
60 Availability::Required => 1,
61
62 Availability::Optional => 2,
63
64 Availability::SameAsTarget => 3,
65
66 Availability::Transitional => 4,
67 }));
68
69 Ok(())
70 }
71 }
72
73 impl ::core::convert::From<crate::wire::Availability> for Availability {
74 fn from(wire: crate::wire::Availability) -> Self {
75 match u32::from(wire.value) {
76 1 => Self::Required,
77
78 2 => Self::Optional,
79
80 3 => Self::SameAsTarget,
81
82 4 => Self::Transitional,
83
84 _ => unsafe { ::core::hint::unreachable_unchecked() },
85 }
86 }
87 }
88
89 impl ::fidl_next::FromWire<crate::wire::Availability> for Availability {
90 #[inline]
91 fn from_wire(wire: crate::wire::Availability) -> Self {
92 Self::from(wire)
93 }
94 }
95
96 impl ::fidl_next::FromWireRef<crate::wire::Availability> for Availability {
97 #[inline]
98 fn from_wire_ref(wire: &crate::wire::Availability) -> Self {
99 Self::from(*wire)
100 }
101 }
102
103 pub type Unit = ();
104
105 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
106 pub enum Data {
107 Bytes(::std::vec::Vec<u8>),
108
109 String(::std::string::String),
110
111 Int64(i64),
112
113 Uint64(u64),
114
115 UnknownOrdinal_(u64),
116 }
117
118 impl Data {
119 pub fn is_unknown(&self) -> bool {
120 #[allow(unreachable_patterns)]
121 match self {
122 Self::UnknownOrdinal_(_) => true,
123 _ => false,
124 }
125 }
126 }
127
128 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Data<'static>, ___E> for Data
129 where
130 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
131 ___E: ::fidl_next::Encoder,
132 {
133 #[inline]
134 fn encode(
135 self,
136 encoder: &mut ___E,
137 out: &mut ::core::mem::MaybeUninit<crate::wire::Data<'static>>,
138 _: (),
139 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
140 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
141
142 match self {
143 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
144 ___E,
145 ::fidl_next::wire::Vector<'static, u8>,
146 >(value, 1, encoder, raw, (8192, ()))?,
147
148 Self::String(value) => ::fidl_next::wire::Union::encode_as::<
149 ___E,
150 ::fidl_next::wire::String<'static>,
151 >(value, 2, encoder, raw, 8192)?,
152
153 Self::Int64(value) => ::fidl_next::wire::Union::encode_as::<
154 ___E,
155 ::fidl_next::wire::Int64,
156 >(value, 3, encoder, raw, ())?,
157
158 Self::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
159 ___E,
160 ::fidl_next::wire::Uint64,
161 >(value, 4, encoder, raw, ())?,
162
163 Self::UnknownOrdinal_(ordinal) => {
164 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
165 }
166 }
167
168 Ok(())
169 }
170 }
171
172 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Data<'static>, ___E> for &'a Data
173 where
174 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
175 ___E: ::fidl_next::Encoder,
176 {
177 #[inline]
178 fn encode(
179 self,
180 encoder: &mut ___E,
181 out: &mut ::core::mem::MaybeUninit<crate::wire::Data<'static>>,
182 _: (),
183 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
184 ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
185
186 match self {
187 Data::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
188 ___E,
189 ::fidl_next::wire::Vector<'static, u8>,
190 >(value, 1, encoder, raw, (8192, ()))?,
191
192 Data::String(value) => ::fidl_next::wire::Union::encode_as::<
193 ___E,
194 ::fidl_next::wire::String<'static>,
195 >(value, 2, encoder, raw, 8192)?,
196
197 Data::Int64(value) => ::fidl_next::wire::Union::encode_as::<
198 ___E,
199 ::fidl_next::wire::Int64,
200 >(value, 3, encoder, raw, ())?,
201
202 Data::Uint64(value) => ::fidl_next::wire::Union::encode_as::<
203 ___E,
204 ::fidl_next::wire::Uint64,
205 >(value, 4, encoder, raw, ())?,
206
207 Data::UnknownOrdinal_(ordinal) => {
208 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
209 }
210 }
211
212 Ok(())
213 }
214 }
215
216 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Data<'static>, ___E> for Data
217 where
218 ___E: ?Sized,
219 Data: ::fidl_next::Encode<crate::wire::Data<'static>, ___E>,
220 {
221 #[inline]
222 fn encode_option(
223 this: ::core::option::Option<Self>,
224 encoder: &mut ___E,
225 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Data<'static>>,
226 _: (),
227 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
228 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
229
230 if let Some(inner) = this {
231 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
232 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
233 } else {
234 ::fidl_next::wire::Union::encode_absent(raw);
235 }
236
237 Ok(())
238 }
239 }
240
241 unsafe impl<'a, ___E> ::fidl_next::EncodeOption<crate::wire_optional::Data<'static>, ___E>
242 for &'a Data
243 where
244 ___E: ?Sized,
245 &'a Data: ::fidl_next::Encode<crate::wire::Data<'static>, ___E>,
246 {
247 #[inline]
248 fn encode_option(
249 this: ::core::option::Option<Self>,
250 encoder: &mut ___E,
251 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Data<'static>>,
252 _: (),
253 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
254 ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
255
256 if let Some(inner) = this {
257 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
258 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
259 } else {
260 ::fidl_next::wire::Union::encode_absent(raw);
261 }
262
263 Ok(())
264 }
265 }
266
267 impl<'de> ::fidl_next::FromWire<crate::wire::Data<'de>> for Data {
268 #[inline]
269 fn from_wire(wire: crate::wire::Data<'de>) -> Self {
270 let wire = ::core::mem::ManuallyDrop::new(wire);
271 match wire.raw.ordinal() {
272 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
273 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
274 })),
275
276 2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
277 wire.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
278 })),
279
280 3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
281 wire.raw.get().read_unchecked::<::fidl_next::wire::Int64>()
282 })),
283
284 4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
285 wire.raw.get().read_unchecked::<::fidl_next::wire::Uint64>()
286 })),
287
288 ord => return Self::UnknownOrdinal_(ord as u64),
289 }
290 }
291 }
292
293 impl<'de> ::fidl_next::FromWireRef<crate::wire::Data<'de>> for Data {
294 #[inline]
295 fn from_wire_ref(wire: &crate::wire::Data<'de>) -> Self {
296 match wire.raw.ordinal() {
297 1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
298 wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
299 })),
300
301 2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
302 wire.raw.get().deref_unchecked::<::fidl_next::wire::String<'de>>()
303 })),
304
305 3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
306 wire.raw.get().deref_unchecked::<::fidl_next::wire::Int64>()
307 })),
308
309 4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
310 wire.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
311 })),
312
313 ord => return Self::UnknownOrdinal_(ord as u64),
314 }
315 }
316 }
317
318 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Data {
319 #[inline]
320 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
321 if let Some(inner) = wire.into_option() {
322 Some(::fidl_next::FromWire::from_wire(inner))
323 } else {
324 None
325 }
326 }
327 }
328
329 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Box<Data> {
330 #[inline]
331 fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
332 <
333 Data as ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>>
334 >::from_wire_option(wire).map(Box::new)
335 }
336 }
337
338 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::Data<'de>> for Box<Data> {
339 #[inline]
340 fn from_wire_option_ref(
341 wire: &crate::wire_optional::Data<'de>,
342 ) -> ::core::option::Option<Self> {
343 if let Some(inner) = wire.as_ref() {
344 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
345 } else {
346 None
347 }
348 }
349 }
350
351 #[doc = " A client-assigned id of a [Capability] in a [CapabilityStore].\n\n The id is relative to the [CapabilityStore]. In the case where two\n [CapabilityStore]s have a capability / assigned to the same id, there is\n no relation between them\n"]
352 pub type CapabilityId = u64;
353
354 #[doc = " A client-assigned id of a new [Capability] in a [CapabilityStore]. Same as [CapabilityId],\n but used to distinguish output parameters in [CapabilityStore] methods.\n"]
355 pub type NewCapabilityId = u64;
356
357 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
358 #[repr(C)]
359 pub struct CapabilityStoreDuplicateRequest {
360 pub id: u64,
361
362 pub dest_id: u64,
363 }
364
365 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
366 for CapabilityStoreDuplicateRequest
367 where
368 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
369 {
370 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
371 Self,
372 crate::wire::CapabilityStoreDuplicateRequest,
373 > = unsafe {
374 ::fidl_next::CopyOptimization::enable_if(
375 true
376
377 && <
378 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
379 >::COPY_OPTIMIZATION.is_enabled()
380
381 && <
382 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
383 >::COPY_OPTIMIZATION.is_enabled()
384
385 )
386 };
387
388 #[inline]
389 fn encode(
390 self,
391 encoder_: &mut ___E,
392 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
393 _: (),
394 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
395 ::fidl_next::munge! {
396 let crate::wire::CapabilityStoreDuplicateRequest {
397 id,
398 dest_id,
399
400 } = out_;
401 }
402
403 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
404
405 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
406
407 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
408
409 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
410
411 Ok(())
412 }
413 }
414
415 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
416 for &'a CapabilityStoreDuplicateRequest
417 where
418 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
419 {
420 #[inline]
421 fn encode(
422 self,
423 encoder_: &mut ___E,
424 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
425 _: (),
426 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
427 ::fidl_next::munge! {
428 let crate::wire::CapabilityStoreDuplicateRequest {
429 id,
430 dest_id,
431
432 } = out_;
433 }
434
435 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
436
437 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
438
439 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
440
441 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
442
443 Ok(())
444 }
445 }
446
447 unsafe impl<___E>
448 ::fidl_next::EncodeOption<
449 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
450 ___E,
451 > for CapabilityStoreDuplicateRequest
452 where
453 ___E: ::fidl_next::Encoder + ?Sized,
454 CapabilityStoreDuplicateRequest:
455 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>,
456 {
457 #[inline]
458 fn encode_option(
459 this: ::core::option::Option<Self>,
460 encoder: &mut ___E,
461 out: &mut ::core::mem::MaybeUninit<
462 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
463 >,
464 _: (),
465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
466 if let Some(inner) = this {
467 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
468 ::fidl_next::wire::Box::encode_present(out);
469 } else {
470 ::fidl_next::wire::Box::encode_absent(out);
471 }
472
473 Ok(())
474 }
475 }
476
477 unsafe impl<'a, ___E>
478 ::fidl_next::EncodeOption<
479 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
480 ___E,
481 > for &'a CapabilityStoreDuplicateRequest
482 where
483 ___E: ::fidl_next::Encoder + ?Sized,
484 &'a CapabilityStoreDuplicateRequest:
485 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>,
486 {
487 #[inline]
488 fn encode_option(
489 this: ::core::option::Option<Self>,
490 encoder: &mut ___E,
491 out: &mut ::core::mem::MaybeUninit<
492 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDuplicateRequest>,
493 >,
494 _: (),
495 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
496 if let Some(inner) = this {
497 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
498 ::fidl_next::wire::Box::encode_present(out);
499 } else {
500 ::fidl_next::wire::Box::encode_absent(out);
501 }
502
503 Ok(())
504 }
505 }
506
507 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateRequest>
508 for CapabilityStoreDuplicateRequest
509 {
510 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
511 crate::wire::CapabilityStoreDuplicateRequest,
512 Self,
513 > = unsafe {
514 ::fidl_next::CopyOptimization::enable_if(
515 true
516 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
517 .is_enabled()
518 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
519 .is_enabled(),
520 )
521 };
522
523 #[inline]
524 fn from_wire(wire: crate::wire::CapabilityStoreDuplicateRequest) -> Self {
525 Self {
526 id: ::fidl_next::FromWire::from_wire(wire.id),
527
528 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
529 }
530 }
531 }
532
533 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateRequest>
534 for CapabilityStoreDuplicateRequest
535 {
536 #[inline]
537 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateRequest) -> Self {
538 Self {
539 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
540
541 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
542 }
543 }
544 }
545
546 pub type CapabilityStoreDuplicateResponse = ();
547
548 #[doc = " Error returned from methods in [CapabilityStore].\n"]
549 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
550 #[repr(u32)]
551 pub enum CapabilityStoreError {
552 IdNotFound = 1,
553 IdAlreadyExists = 2,
554 BadCapability = 3,
555 WrongType = 4,
556 NotDuplicatable = 5,
557 ItemNotFound = 6,
558 ItemAlreadyExists = 7,
559 InvalidKey = 8,
560 InvalidArgs = 9,
561 UnknownOrdinal_(u32) = 10,
562 }
563 impl ::std::convert::From<u32> for CapabilityStoreError {
564 fn from(value: u32) -> Self {
565 match value {
566 1 => Self::IdNotFound,
567 2 => Self::IdAlreadyExists,
568 3 => Self::BadCapability,
569 4 => Self::WrongType,
570 5 => Self::NotDuplicatable,
571 6 => Self::ItemNotFound,
572 7 => Self::ItemAlreadyExists,
573 8 => Self::InvalidKey,
574 9 => Self::InvalidArgs,
575
576 _ => Self::UnknownOrdinal_(value),
577 }
578 }
579 }
580
581 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreError, ___E>
582 for CapabilityStoreError
583 where
584 ___E: ?Sized,
585 {
586 #[inline]
587 fn encode(
588 self,
589 encoder: &mut ___E,
590 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreError>,
591 _: (),
592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
593 ::fidl_next::Encode::encode(&self, encoder, out, ())
594 }
595 }
596
597 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreError, ___E>
598 for &'a CapabilityStoreError
599 where
600 ___E: ?Sized,
601 {
602 #[inline]
603 fn encode(
604 self,
605 encoder: &mut ___E,
606 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreError>,
607 _: (),
608 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
609 ::fidl_next::munge!(let crate::wire::CapabilityStoreError { value } = out);
610 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
611 CapabilityStoreError::IdNotFound => 1,
612
613 CapabilityStoreError::IdAlreadyExists => 2,
614
615 CapabilityStoreError::BadCapability => 3,
616
617 CapabilityStoreError::WrongType => 4,
618
619 CapabilityStoreError::NotDuplicatable => 5,
620
621 CapabilityStoreError::ItemNotFound => 6,
622
623 CapabilityStoreError::ItemAlreadyExists => 7,
624
625 CapabilityStoreError::InvalidKey => 8,
626
627 CapabilityStoreError::InvalidArgs => 9,
628
629 CapabilityStoreError::UnknownOrdinal_(value) => value,
630 }));
631
632 Ok(())
633 }
634 }
635
636 impl ::core::convert::From<crate::wire::CapabilityStoreError> for CapabilityStoreError {
637 fn from(wire: crate::wire::CapabilityStoreError) -> Self {
638 match u32::from(wire.value) {
639 1 => Self::IdNotFound,
640
641 2 => Self::IdAlreadyExists,
642
643 3 => Self::BadCapability,
644
645 4 => Self::WrongType,
646
647 5 => Self::NotDuplicatable,
648
649 6 => Self::ItemNotFound,
650
651 7 => Self::ItemAlreadyExists,
652
653 8 => Self::InvalidKey,
654
655 9 => Self::InvalidArgs,
656
657 value => Self::UnknownOrdinal_(value),
658 }
659 }
660 }
661
662 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreError> for CapabilityStoreError {
663 #[inline]
664 fn from_wire(wire: crate::wire::CapabilityStoreError) -> Self {
665 Self::from(wire)
666 }
667 }
668
669 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreError> for CapabilityStoreError {
670 #[inline]
671 fn from_wire_ref(wire: &crate::wire::CapabilityStoreError) -> Self {
672 Self::from(*wire)
673 }
674 }
675
676 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
677 #[repr(C)]
678 pub struct CapabilityStoreDropRequest {
679 pub id: u64,
680 }
681
682 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
683 for CapabilityStoreDropRequest
684 where
685 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
686 {
687 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
688 Self,
689 crate::wire::CapabilityStoreDropRequest,
690 > = unsafe {
691 ::fidl_next::CopyOptimization::enable_if(
692 true
693
694 && <
695 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
696 >::COPY_OPTIMIZATION.is_enabled()
697
698 )
699 };
700
701 #[inline]
702 fn encode(
703 self,
704 encoder_: &mut ___E,
705 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
706 _: (),
707 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
708 ::fidl_next::munge! {
709 let crate::wire::CapabilityStoreDropRequest {
710 id,
711
712 } = out_;
713 }
714
715 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
716
717 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
718
719 Ok(())
720 }
721 }
722
723 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
724 for &'a CapabilityStoreDropRequest
725 where
726 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
727 {
728 #[inline]
729 fn encode(
730 self,
731 encoder_: &mut ___E,
732 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
733 _: (),
734 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
735 ::fidl_next::munge! {
736 let crate::wire::CapabilityStoreDropRequest {
737 id,
738
739 } = out_;
740 }
741
742 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
743
744 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
745
746 Ok(())
747 }
748 }
749
750 unsafe impl<___E>
751 ::fidl_next::EncodeOption<
752 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
753 ___E,
754 > for CapabilityStoreDropRequest
755 where
756 ___E: ::fidl_next::Encoder + ?Sized,
757 CapabilityStoreDropRequest:
758 ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>,
759 {
760 #[inline]
761 fn encode_option(
762 this: ::core::option::Option<Self>,
763 encoder: &mut ___E,
764 out: &mut ::core::mem::MaybeUninit<
765 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
766 >,
767 _: (),
768 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
769 if let Some(inner) = this {
770 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
771 ::fidl_next::wire::Box::encode_present(out);
772 } else {
773 ::fidl_next::wire::Box::encode_absent(out);
774 }
775
776 Ok(())
777 }
778 }
779
780 unsafe impl<'a, ___E>
781 ::fidl_next::EncodeOption<
782 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
783 ___E,
784 > for &'a CapabilityStoreDropRequest
785 where
786 ___E: ::fidl_next::Encoder + ?Sized,
787 &'a CapabilityStoreDropRequest:
788 ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>,
789 {
790 #[inline]
791 fn encode_option(
792 this: ::core::option::Option<Self>,
793 encoder: &mut ___E,
794 out: &mut ::core::mem::MaybeUninit<
795 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDropRequest>,
796 >,
797 _: (),
798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
799 if let Some(inner) = this {
800 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
801 ::fidl_next::wire::Box::encode_present(out);
802 } else {
803 ::fidl_next::wire::Box::encode_absent(out);
804 }
805
806 Ok(())
807 }
808 }
809
810 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropRequest> for CapabilityStoreDropRequest {
811 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
812 crate::wire::CapabilityStoreDropRequest,
813 Self,
814 > = unsafe {
815 ::fidl_next::CopyOptimization::enable_if(
816 true
817 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
818 .is_enabled(),
819 )
820 };
821
822 #[inline]
823 fn from_wire(wire: crate::wire::CapabilityStoreDropRequest) -> Self {
824 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
825 }
826 }
827
828 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropRequest>
829 for CapabilityStoreDropRequest
830 {
831 #[inline]
832 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropRequest) -> Self {
833 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
834 }
835 }
836
837 pub type CapabilityStoreDropResponse = ();
838
839 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
840 #[repr(C)]
841 pub struct CapabilityStoreExportRequest {
842 pub id: u64,
843 }
844
845 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
846 for CapabilityStoreExportRequest
847 where
848 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
849 {
850 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
851 Self,
852 crate::wire::CapabilityStoreExportRequest,
853 > = unsafe {
854 ::fidl_next::CopyOptimization::enable_if(
855 true
856
857 && <
858 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
859 >::COPY_OPTIMIZATION.is_enabled()
860
861 )
862 };
863
864 #[inline]
865 fn encode(
866 self,
867 encoder_: &mut ___E,
868 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
869 _: (),
870 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
871 ::fidl_next::munge! {
872 let crate::wire::CapabilityStoreExportRequest {
873 id,
874
875 } = out_;
876 }
877
878 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
879
880 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
881
882 Ok(())
883 }
884 }
885
886 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
887 for &'a CapabilityStoreExportRequest
888 where
889 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
890 {
891 #[inline]
892 fn encode(
893 self,
894 encoder_: &mut ___E,
895 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
896 _: (),
897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
898 ::fidl_next::munge! {
899 let crate::wire::CapabilityStoreExportRequest {
900 id,
901
902 } = out_;
903 }
904
905 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
906
907 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
908
909 Ok(())
910 }
911 }
912
913 unsafe impl<___E>
914 ::fidl_next::EncodeOption<
915 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
916 ___E,
917 > for CapabilityStoreExportRequest
918 where
919 ___E: ::fidl_next::Encoder + ?Sized,
920 CapabilityStoreExportRequest:
921 ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>,
922 {
923 #[inline]
924 fn encode_option(
925 this: ::core::option::Option<Self>,
926 encoder: &mut ___E,
927 out: &mut ::core::mem::MaybeUninit<
928 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
929 >,
930 _: (),
931 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
932 if let Some(inner) = this {
933 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
934 ::fidl_next::wire::Box::encode_present(out);
935 } else {
936 ::fidl_next::wire::Box::encode_absent(out);
937 }
938
939 Ok(())
940 }
941 }
942
943 unsafe impl<'a, ___E>
944 ::fidl_next::EncodeOption<
945 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
946 ___E,
947 > for &'a CapabilityStoreExportRequest
948 where
949 ___E: ::fidl_next::Encoder + ?Sized,
950 &'a CapabilityStoreExportRequest:
951 ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>,
952 {
953 #[inline]
954 fn encode_option(
955 this: ::core::option::Option<Self>,
956 encoder: &mut ___E,
957 out: &mut ::core::mem::MaybeUninit<
958 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreExportRequest>,
959 >,
960 _: (),
961 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
962 if let Some(inner) = this {
963 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
964 ::fidl_next::wire::Box::encode_present(out);
965 } else {
966 ::fidl_next::wire::Box::encode_absent(out);
967 }
968
969 Ok(())
970 }
971 }
972
973 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreExportRequest>
974 for CapabilityStoreExportRequest
975 {
976 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
977 crate::wire::CapabilityStoreExportRequest,
978 Self,
979 > = unsafe {
980 ::fidl_next::CopyOptimization::enable_if(
981 true
982 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
983 .is_enabled(),
984 )
985 };
986
987 #[inline]
988 fn from_wire(wire: crate::wire::CapabilityStoreExportRequest) -> Self {
989 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
990 }
991 }
992
993 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreExportRequest>
994 for CapabilityStoreExportRequest
995 {
996 #[inline]
997 fn from_wire_ref(wire: &crate::wire::CapabilityStoreExportRequest) -> Self {
998 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
999 }
1000 }
1001
1002 pub type CapabilityStoreImportResponse = ();
1003
1004 pub type CapabilityStoreConnectorCreateResponse = ();
1005
1006 pub type CapabilityStoreConnectorOpenResponse = ();
1007
1008 pub type CapabilityStoreDirConnectorCreateResponse = ();
1009
1010 pub type CapabilityStoreDirConnectorOpenResponse = ();
1011
1012 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1013 #[repr(C)]
1014 pub struct CapabilityStoreDictionaryCreateRequest {
1015 pub id: u64,
1016 }
1017
1018 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
1019 for CapabilityStoreDictionaryCreateRequest
1020 where
1021 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1022 {
1023 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1024 Self,
1025 crate::wire::CapabilityStoreDictionaryCreateRequest,
1026 > = unsafe {
1027 ::fidl_next::CopyOptimization::enable_if(
1028 true
1029
1030 && <
1031 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1032 >::COPY_OPTIMIZATION.is_enabled()
1033
1034 )
1035 };
1036
1037 #[inline]
1038 fn encode(
1039 self,
1040 encoder_: &mut ___E,
1041 out_: &mut ::core::mem::MaybeUninit<
1042 crate::wire::CapabilityStoreDictionaryCreateRequest,
1043 >,
1044 _: (),
1045 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1046 ::fidl_next::munge! {
1047 let crate::wire::CapabilityStoreDictionaryCreateRequest {
1048 id,
1049
1050 } = out_;
1051 }
1052
1053 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1054
1055 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1056
1057 Ok(())
1058 }
1059 }
1060
1061 unsafe impl<'a, ___E>
1062 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
1063 for &'a CapabilityStoreDictionaryCreateRequest
1064 where
1065 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1066 {
1067 #[inline]
1068 fn encode(
1069 self,
1070 encoder_: &mut ___E,
1071 out_: &mut ::core::mem::MaybeUninit<
1072 crate::wire::CapabilityStoreDictionaryCreateRequest,
1073 >,
1074 _: (),
1075 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1076 ::fidl_next::munge! {
1077 let crate::wire::CapabilityStoreDictionaryCreateRequest {
1078 id,
1079
1080 } = out_;
1081 }
1082
1083 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1084
1085 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1086
1087 Ok(())
1088 }
1089 }
1090
1091 unsafe impl<___E>
1092 ::fidl_next::EncodeOption<
1093 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>,
1094 ___E,
1095 > for CapabilityStoreDictionaryCreateRequest
1096 where
1097 ___E: ::fidl_next::Encoder + ?Sized,
1098 CapabilityStoreDictionaryCreateRequest:
1099 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>,
1100 {
1101 #[inline]
1102 fn encode_option(
1103 this: ::core::option::Option<Self>,
1104 encoder: &mut ___E,
1105 out: &mut ::core::mem::MaybeUninit<
1106 ::fidl_next::wire::Box<
1107 'static,
1108 crate::wire::CapabilityStoreDictionaryCreateRequest,
1109 >,
1110 >,
1111 _: (),
1112 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1113 if let Some(inner) = this {
1114 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1115 ::fidl_next::wire::Box::encode_present(out);
1116 } else {
1117 ::fidl_next::wire::Box::encode_absent(out);
1118 }
1119
1120 Ok(())
1121 }
1122 }
1123
1124 unsafe impl<'a, ___E>
1125 ::fidl_next::EncodeOption<
1126 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>,
1127 ___E,
1128 > for &'a CapabilityStoreDictionaryCreateRequest
1129 where
1130 ___E: ::fidl_next::Encoder + ?Sized,
1131 &'a CapabilityStoreDictionaryCreateRequest:
1132 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>,
1133 {
1134 #[inline]
1135 fn encode_option(
1136 this: ::core::option::Option<Self>,
1137 encoder: &mut ___E,
1138 out: &mut ::core::mem::MaybeUninit<
1139 ::fidl_next::wire::Box<
1140 'static,
1141 crate::wire::CapabilityStoreDictionaryCreateRequest,
1142 >,
1143 >,
1144 _: (),
1145 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1146 if let Some(inner) = this {
1147 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1148 ::fidl_next::wire::Box::encode_present(out);
1149 } else {
1150 ::fidl_next::wire::Box::encode_absent(out);
1151 }
1152
1153 Ok(())
1154 }
1155 }
1156
1157 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateRequest>
1158 for CapabilityStoreDictionaryCreateRequest
1159 {
1160 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1161 crate::wire::CapabilityStoreDictionaryCreateRequest,
1162 Self,
1163 > = unsafe {
1164 ::fidl_next::CopyOptimization::enable_if(
1165 true
1166 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1167 .is_enabled(),
1168 )
1169 };
1170
1171 #[inline]
1172 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
1173 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1174 }
1175 }
1176
1177 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateRequest>
1178 for CapabilityStoreDictionaryCreateRequest
1179 {
1180 #[inline]
1181 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
1182 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1183 }
1184 }
1185
1186 pub type CapabilityStoreDictionaryCreateResponse = ();
1187
1188 pub type CapabilityStoreDictionaryLegacyImportResponse = ();
1189
1190 pub type CapabilityStoreDictionaryLegacyExportResponse = ();
1191
1192 #[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
1193 pub type DictionaryKey = ::std::string::String;
1194
1195 #[doc = " A key-value pair in a [`DictionaryRef`].\n"]
1196 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1197 pub struct DictionaryItem {
1198 pub key: ::std::string::String,
1199
1200 pub value: u64,
1201 }
1202
1203 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E> for DictionaryItem
1204 where
1205 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1206 ___E: ::fidl_next::Encoder,
1207 {
1208 #[inline]
1209 fn encode(
1210 self,
1211 encoder_: &mut ___E,
1212 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
1213 _: (),
1214 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1215 ::fidl_next::munge! {
1216 let crate::wire::DictionaryItem {
1217 key,
1218 value,
1219
1220 } = out_;
1221 }
1222
1223 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
1224
1225 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1226 ::fidl_next::Constrained::validate(_field, 255)?;
1227
1228 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
1229
1230 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
1231
1232 Ok(())
1233 }
1234 }
1235
1236 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>
1237 for &'a DictionaryItem
1238 where
1239 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1240 ___E: ::fidl_next::Encoder,
1241 {
1242 #[inline]
1243 fn encode(
1244 self,
1245 encoder_: &mut ___E,
1246 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
1247 _: (),
1248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1249 ::fidl_next::munge! {
1250 let crate::wire::DictionaryItem {
1251 key,
1252 value,
1253
1254 } = out_;
1255 }
1256
1257 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
1258
1259 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1260 ::fidl_next::Constrained::validate(_field, 255)?;
1261
1262 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
1263
1264 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
1265
1266 Ok(())
1267 }
1268 }
1269
1270 unsafe impl<___E>
1271 ::fidl_next::EncodeOption<
1272 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
1273 ___E,
1274 > for DictionaryItem
1275 where
1276 ___E: ::fidl_next::Encoder + ?Sized,
1277 DictionaryItem: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
1278 {
1279 #[inline]
1280 fn encode_option(
1281 this: ::core::option::Option<Self>,
1282 encoder: &mut ___E,
1283 out: &mut ::core::mem::MaybeUninit<
1284 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
1285 >,
1286 _: (),
1287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1288 if let Some(inner) = this {
1289 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1290 ::fidl_next::wire::Box::encode_present(out);
1291 } else {
1292 ::fidl_next::wire::Box::encode_absent(out);
1293 }
1294
1295 Ok(())
1296 }
1297 }
1298
1299 unsafe impl<'a, ___E>
1300 ::fidl_next::EncodeOption<
1301 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
1302 ___E,
1303 > for &'a DictionaryItem
1304 where
1305 ___E: ::fidl_next::Encoder + ?Sized,
1306 &'a DictionaryItem: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
1307 {
1308 #[inline]
1309 fn encode_option(
1310 this: ::core::option::Option<Self>,
1311 encoder: &mut ___E,
1312 out: &mut ::core::mem::MaybeUninit<
1313 ::fidl_next::wire::Box<'static, crate::wire::DictionaryItem<'static>>,
1314 >,
1315 _: (),
1316 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1317 if let Some(inner) = this {
1318 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1319 ::fidl_next::wire::Box::encode_present(out);
1320 } else {
1321 ::fidl_next::wire::Box::encode_absent(out);
1322 }
1323
1324 Ok(())
1325 }
1326 }
1327
1328 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryItem<'de>> for DictionaryItem {
1329 #[inline]
1330 fn from_wire(wire: crate::wire::DictionaryItem<'de>) -> Self {
1331 Self {
1332 key: ::fidl_next::FromWire::from_wire(wire.key),
1333
1334 value: ::fidl_next::FromWire::from_wire(wire.value),
1335 }
1336 }
1337 }
1338
1339 impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryItem<'de>> for DictionaryItem {
1340 #[inline]
1341 fn from_wire_ref(wire: &crate::wire::DictionaryItem<'de>) -> Self {
1342 Self {
1343 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
1344
1345 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
1346 }
1347 }
1348 }
1349
1350 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1351 pub struct CapabilityStoreDictionaryInsertRequest {
1352 pub id: u64,
1353
1354 pub item: crate::natural::DictionaryItem,
1355 }
1356
1357 unsafe impl<___E>
1358 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
1359 for CapabilityStoreDictionaryInsertRequest
1360 where
1361 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1362 ___E: ::fidl_next::Encoder,
1363 {
1364 #[inline]
1365 fn encode(
1366 self,
1367 encoder_: &mut ___E,
1368 out_: &mut ::core::mem::MaybeUninit<
1369 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1370 >,
1371 _: (),
1372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1373 ::fidl_next::munge! {
1374 let crate::wire::CapabilityStoreDictionaryInsertRequest {
1375 id,
1376 item,
1377
1378 } = out_;
1379 }
1380
1381 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1382
1383 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1384
1385 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
1386
1387 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
1388
1389 Ok(())
1390 }
1391 }
1392
1393 unsafe impl<'a, ___E>
1394 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
1395 for &'a CapabilityStoreDictionaryInsertRequest
1396 where
1397 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1398 ___E: ::fidl_next::Encoder,
1399 {
1400 #[inline]
1401 fn encode(
1402 self,
1403 encoder_: &mut ___E,
1404 out_: &mut ::core::mem::MaybeUninit<
1405 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1406 >,
1407 _: (),
1408 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1409 ::fidl_next::munge! {
1410 let crate::wire::CapabilityStoreDictionaryInsertRequest {
1411 id,
1412 item,
1413
1414 } = out_;
1415 }
1416
1417 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1418
1419 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1420
1421 ::fidl_next::Encode::encode(&self.item, encoder_, item, ())?;
1422
1423 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
1424
1425 Ok(())
1426 }
1427 }
1428
1429 unsafe impl<___E>
1430 ::fidl_next::EncodeOption<
1431 ::fidl_next::wire::Box<
1432 'static,
1433 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1434 >,
1435 ___E,
1436 > for CapabilityStoreDictionaryInsertRequest
1437 where
1438 ___E: ::fidl_next::Encoder + ?Sized,
1439 CapabilityStoreDictionaryInsertRequest:
1440 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>,
1441 {
1442 #[inline]
1443 fn encode_option(
1444 this: ::core::option::Option<Self>,
1445 encoder: &mut ___E,
1446 out: &mut ::core::mem::MaybeUninit<
1447 ::fidl_next::wire::Box<
1448 'static,
1449 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1450 >,
1451 >,
1452 _: (),
1453 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1454 if let Some(inner) = this {
1455 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1456 ::fidl_next::wire::Box::encode_present(out);
1457 } else {
1458 ::fidl_next::wire::Box::encode_absent(out);
1459 }
1460
1461 Ok(())
1462 }
1463 }
1464
1465 unsafe impl<'a, ___E>
1466 ::fidl_next::EncodeOption<
1467 ::fidl_next::wire::Box<
1468 'static,
1469 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1470 >,
1471 ___E,
1472 > for &'a CapabilityStoreDictionaryInsertRequest
1473 where
1474 ___E: ::fidl_next::Encoder + ?Sized,
1475 &'a CapabilityStoreDictionaryInsertRequest:
1476 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>,
1477 {
1478 #[inline]
1479 fn encode_option(
1480 this: ::core::option::Option<Self>,
1481 encoder: &mut ___E,
1482 out: &mut ::core::mem::MaybeUninit<
1483 ::fidl_next::wire::Box<
1484 'static,
1485 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
1486 >,
1487 >,
1488 _: (),
1489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1490 if let Some(inner) = this {
1491 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1492 ::fidl_next::wire::Box::encode_present(out);
1493 } else {
1494 ::fidl_next::wire::Box::encode_absent(out);
1495 }
1496
1497 Ok(())
1498 }
1499 }
1500
1501 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
1502 for CapabilityStoreDictionaryInsertRequest
1503 {
1504 #[inline]
1505 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
1506 Self {
1507 id: ::fidl_next::FromWire::from_wire(wire.id),
1508
1509 item: ::fidl_next::FromWire::from_wire(wire.item),
1510 }
1511 }
1512 }
1513
1514 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
1515 for CapabilityStoreDictionaryInsertRequest
1516 {
1517 #[inline]
1518 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
1519 Self {
1520 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1521
1522 item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
1523 }
1524 }
1525 }
1526
1527 pub type CapabilityStoreDictionaryInsertResponse = ();
1528
1529 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1530 pub struct CapabilityStoreDictionaryGetRequest {
1531 pub id: u64,
1532
1533 pub key: ::std::string::String,
1534
1535 pub dest_id: u64,
1536 }
1537
1538 unsafe impl<___E>
1539 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
1540 for CapabilityStoreDictionaryGetRequest
1541 where
1542 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1543 ___E: ::fidl_next::Encoder,
1544 {
1545 #[inline]
1546 fn encode(
1547 self,
1548 encoder_: &mut ___E,
1549 out_: &mut ::core::mem::MaybeUninit<
1550 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1551 >,
1552 _: (),
1553 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1554 ::fidl_next::munge! {
1555 let crate::wire::CapabilityStoreDictionaryGetRequest {
1556 id,
1557 key,
1558 dest_id,
1559
1560 } = out_;
1561 }
1562
1563 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1564
1565 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1566
1567 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
1568
1569 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1570 ::fidl_next::Constrained::validate(_field, 255)?;
1571
1572 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
1573
1574 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1575
1576 Ok(())
1577 }
1578 }
1579
1580 unsafe impl<'a, ___E>
1581 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
1582 for &'a CapabilityStoreDictionaryGetRequest
1583 where
1584 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1585 ___E: ::fidl_next::Encoder,
1586 {
1587 #[inline]
1588 fn encode(
1589 self,
1590 encoder_: &mut ___E,
1591 out_: &mut ::core::mem::MaybeUninit<
1592 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1593 >,
1594 _: (),
1595 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1596 ::fidl_next::munge! {
1597 let crate::wire::CapabilityStoreDictionaryGetRequest {
1598 id,
1599 key,
1600 dest_id,
1601
1602 } = out_;
1603 }
1604
1605 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1606
1607 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1608
1609 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
1610
1611 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1612 ::fidl_next::Constrained::validate(_field, 255)?;
1613
1614 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
1615
1616 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1617
1618 Ok(())
1619 }
1620 }
1621
1622 unsafe impl<___E>
1623 ::fidl_next::EncodeOption<
1624 ::fidl_next::wire::Box<
1625 'static,
1626 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1627 >,
1628 ___E,
1629 > for CapabilityStoreDictionaryGetRequest
1630 where
1631 ___E: ::fidl_next::Encoder + ?Sized,
1632 CapabilityStoreDictionaryGetRequest:
1633 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>,
1634 {
1635 #[inline]
1636 fn encode_option(
1637 this: ::core::option::Option<Self>,
1638 encoder: &mut ___E,
1639 out: &mut ::core::mem::MaybeUninit<
1640 ::fidl_next::wire::Box<
1641 'static,
1642 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1643 >,
1644 >,
1645 _: (),
1646 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1647 if let Some(inner) = this {
1648 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1649 ::fidl_next::wire::Box::encode_present(out);
1650 } else {
1651 ::fidl_next::wire::Box::encode_absent(out);
1652 }
1653
1654 Ok(())
1655 }
1656 }
1657
1658 unsafe impl<'a, ___E>
1659 ::fidl_next::EncodeOption<
1660 ::fidl_next::wire::Box<
1661 'static,
1662 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1663 >,
1664 ___E,
1665 > for &'a CapabilityStoreDictionaryGetRequest
1666 where
1667 ___E: ::fidl_next::Encoder + ?Sized,
1668 &'a CapabilityStoreDictionaryGetRequest:
1669 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>,
1670 {
1671 #[inline]
1672 fn encode_option(
1673 this: ::core::option::Option<Self>,
1674 encoder: &mut ___E,
1675 out: &mut ::core::mem::MaybeUninit<
1676 ::fidl_next::wire::Box<
1677 'static,
1678 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
1679 >,
1680 >,
1681 _: (),
1682 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1683 if let Some(inner) = this {
1684 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1685 ::fidl_next::wire::Box::encode_present(out);
1686 } else {
1687 ::fidl_next::wire::Box::encode_absent(out);
1688 }
1689
1690 Ok(())
1691 }
1692 }
1693
1694 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
1695 for CapabilityStoreDictionaryGetRequest
1696 {
1697 #[inline]
1698 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
1699 Self {
1700 id: ::fidl_next::FromWire::from_wire(wire.id),
1701
1702 key: ::fidl_next::FromWire::from_wire(wire.key),
1703
1704 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
1705 }
1706 }
1707 }
1708
1709 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
1710 for CapabilityStoreDictionaryGetRequest
1711 {
1712 #[inline]
1713 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
1714 Self {
1715 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1716
1717 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
1718
1719 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
1720 }
1721 }
1722 }
1723
1724 pub type CapabilityStoreDictionaryGetResponse = ();
1725
1726 #[doc = " A [CapabilityId] wrapped in a struct. This is useful for putting a [CapabilityId] in a `box<>`,\n which FIDL does not allow for pure integral types.\n"]
1727 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1728 #[repr(C)]
1729 pub struct WrappedCapabilityId {
1730 pub id: u64,
1731 }
1732
1733 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
1734 for WrappedCapabilityId
1735 where
1736 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1737 {
1738 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1739 Self,
1740 crate::wire::WrappedCapabilityId,
1741 > = unsafe {
1742 ::fidl_next::CopyOptimization::enable_if(
1743 true
1744
1745 && <
1746 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1747 >::COPY_OPTIMIZATION.is_enabled()
1748
1749 )
1750 };
1751
1752 #[inline]
1753 fn encode(
1754 self,
1755 encoder_: &mut ___E,
1756 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
1757 _: (),
1758 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1759 ::fidl_next::munge! {
1760 let crate::wire::WrappedCapabilityId {
1761 id,
1762
1763 } = out_;
1764 }
1765
1766 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1767
1768 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1769
1770 Ok(())
1771 }
1772 }
1773
1774 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
1775 for &'a WrappedCapabilityId
1776 where
1777 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1778 {
1779 #[inline]
1780 fn encode(
1781 self,
1782 encoder_: &mut ___E,
1783 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
1784 _: (),
1785 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1786 ::fidl_next::munge! {
1787 let crate::wire::WrappedCapabilityId {
1788 id,
1789
1790 } = out_;
1791 }
1792
1793 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1794
1795 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1796
1797 Ok(())
1798 }
1799 }
1800
1801 unsafe impl<___E>
1802 ::fidl_next::EncodeOption<
1803 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
1804 ___E,
1805 > for WrappedCapabilityId
1806 where
1807 ___E: ::fidl_next::Encoder + ?Sized,
1808 WrappedCapabilityId: ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>,
1809 {
1810 #[inline]
1811 fn encode_option(
1812 this: ::core::option::Option<Self>,
1813 encoder: &mut ___E,
1814 out: &mut ::core::mem::MaybeUninit<
1815 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
1816 >,
1817 _: (),
1818 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1819 if let Some(inner) = this {
1820 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1821 ::fidl_next::wire::Box::encode_present(out);
1822 } else {
1823 ::fidl_next::wire::Box::encode_absent(out);
1824 }
1825
1826 Ok(())
1827 }
1828 }
1829
1830 unsafe impl<'a, ___E>
1831 ::fidl_next::EncodeOption<
1832 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
1833 ___E,
1834 > for &'a WrappedCapabilityId
1835 where
1836 ___E: ::fidl_next::Encoder + ?Sized,
1837 &'a WrappedCapabilityId: ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>,
1838 {
1839 #[inline]
1840 fn encode_option(
1841 this: ::core::option::Option<Self>,
1842 encoder: &mut ___E,
1843 out: &mut ::core::mem::MaybeUninit<
1844 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
1845 >,
1846 _: (),
1847 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1848 if let Some(inner) = this {
1849 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1850 ::fidl_next::wire::Box::encode_present(out);
1851 } else {
1852 ::fidl_next::wire::Box::encode_absent(out);
1853 }
1854
1855 Ok(())
1856 }
1857 }
1858
1859 impl ::fidl_next::FromWire<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
1860 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1861 crate::wire::WrappedCapabilityId,
1862 Self,
1863 > = unsafe {
1864 ::fidl_next::CopyOptimization::enable_if(
1865 true
1866 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1867 .is_enabled(),
1868 )
1869 };
1870
1871 #[inline]
1872 fn from_wire(wire: crate::wire::WrappedCapabilityId) -> Self {
1873 Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1874 }
1875 }
1876
1877 impl ::fidl_next::FromWireRef<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
1878 #[inline]
1879 fn from_wire_ref(wire: &crate::wire::WrappedCapabilityId) -> Self {
1880 Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1881 }
1882 }
1883
1884 pub type WrappedNewCapabilityId = crate::natural::WrappedCapabilityId;
1885
1886 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1887 pub struct CapabilityStoreDictionaryRemoveRequest {
1888 pub id: u64,
1889
1890 pub key: ::std::string::String,
1891
1892 pub dest_id: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
1893 }
1894
1895 unsafe impl<___E>
1896 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
1897 for CapabilityStoreDictionaryRemoveRequest
1898 where
1899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1900 ___E: ::fidl_next::Encoder,
1901 {
1902 #[inline]
1903 fn encode(
1904 self,
1905 encoder_: &mut ___E,
1906 out_: &mut ::core::mem::MaybeUninit<
1907 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
1908 >,
1909 _: (),
1910 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1911 ::fidl_next::munge! {
1912 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
1913 id,
1914 key,
1915 dest_id,
1916
1917 } = out_;
1918 }
1919
1920 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1921
1922 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1923
1924 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
1925
1926 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1927 ::fidl_next::Constrained::validate(_field, 255)?;
1928
1929 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
1930
1931 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1932
1933 Ok(())
1934 }
1935 }
1936
1937 unsafe impl<'a, ___E>
1938 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
1939 for &'a CapabilityStoreDictionaryRemoveRequest
1940 where
1941 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1942 ___E: ::fidl_next::Encoder,
1943 {
1944 #[inline]
1945 fn encode(
1946 self,
1947 encoder_: &mut ___E,
1948 out_: &mut ::core::mem::MaybeUninit<
1949 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
1950 >,
1951 _: (),
1952 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1953 ::fidl_next::munge! {
1954 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
1955 id,
1956 key,
1957 dest_id,
1958
1959 } = out_;
1960 }
1961
1962 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1963
1964 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1965
1966 ::fidl_next::Encode::encode(&self.key, encoder_, key, 255)?;
1967
1968 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
1969 ::fidl_next::Constrained::validate(_field, 255)?;
1970
1971 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
1972
1973 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1974
1975 Ok(())
1976 }
1977 }
1978
1979 unsafe impl<___E>
1980 ::fidl_next::EncodeOption<
1981 ::fidl_next::wire::Box<
1982 'static,
1983 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
1984 >,
1985 ___E,
1986 > for CapabilityStoreDictionaryRemoveRequest
1987 where
1988 ___E: ::fidl_next::Encoder + ?Sized,
1989 CapabilityStoreDictionaryRemoveRequest:
1990 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>,
1991 {
1992 #[inline]
1993 fn encode_option(
1994 this: ::core::option::Option<Self>,
1995 encoder: &mut ___E,
1996 out: &mut ::core::mem::MaybeUninit<
1997 ::fidl_next::wire::Box<
1998 'static,
1999 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
2000 >,
2001 >,
2002 _: (),
2003 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2004 if let Some(inner) = this {
2005 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2006 ::fidl_next::wire::Box::encode_present(out);
2007 } else {
2008 ::fidl_next::wire::Box::encode_absent(out);
2009 }
2010
2011 Ok(())
2012 }
2013 }
2014
2015 unsafe impl<'a, ___E>
2016 ::fidl_next::EncodeOption<
2017 ::fidl_next::wire::Box<
2018 'static,
2019 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
2020 >,
2021 ___E,
2022 > for &'a CapabilityStoreDictionaryRemoveRequest
2023 where
2024 ___E: ::fidl_next::Encoder + ?Sized,
2025 &'a CapabilityStoreDictionaryRemoveRequest:
2026 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>,
2027 {
2028 #[inline]
2029 fn encode_option(
2030 this: ::core::option::Option<Self>,
2031 encoder: &mut ___E,
2032 out: &mut ::core::mem::MaybeUninit<
2033 ::fidl_next::wire::Box<
2034 'static,
2035 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
2036 >,
2037 >,
2038 _: (),
2039 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2040 if let Some(inner) = this {
2041 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2042 ::fidl_next::wire::Box::encode_present(out);
2043 } else {
2044 ::fidl_next::wire::Box::encode_absent(out);
2045 }
2046
2047 Ok(())
2048 }
2049 }
2050
2051 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
2052 for CapabilityStoreDictionaryRemoveRequest
2053 {
2054 #[inline]
2055 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
2056 Self {
2057 id: ::fidl_next::FromWire::from_wire(wire.id),
2058
2059 key: ::fidl_next::FromWire::from_wire(wire.key),
2060
2061 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
2062 }
2063 }
2064 }
2065
2066 impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
2067 for CapabilityStoreDictionaryRemoveRequest
2068 {
2069 #[inline]
2070 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
2071 Self {
2072 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
2073
2074 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
2075
2076 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
2077 }
2078 }
2079 }
2080
2081 pub type CapabilityStoreDictionaryRemoveResponse = ();
2082
2083 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2084 #[repr(C)]
2085 pub struct CapabilityStoreDictionaryCopyRequest {
2086 pub id: u64,
2087
2088 pub dest_id: u64,
2089 }
2090
2091 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
2092 for CapabilityStoreDictionaryCopyRequest
2093 where
2094 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2095 {
2096 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2097 Self,
2098 crate::wire::CapabilityStoreDictionaryCopyRequest,
2099 > = unsafe {
2100 ::fidl_next::CopyOptimization::enable_if(
2101 true
2102
2103 && <
2104 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
2105 >::COPY_OPTIMIZATION.is_enabled()
2106
2107 && <
2108 u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
2109 >::COPY_OPTIMIZATION.is_enabled()
2110
2111 )
2112 };
2113
2114 #[inline]
2115 fn encode(
2116 self,
2117 encoder_: &mut ___E,
2118 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
2119 _: (),
2120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2121 ::fidl_next::munge! {
2122 let crate::wire::CapabilityStoreDictionaryCopyRequest {
2123 id,
2124 dest_id,
2125
2126 } = out_;
2127 }
2128
2129 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2130
2131 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2132
2133 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
2134
2135 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
2136
2137 Ok(())
2138 }
2139 }
2140
2141 unsafe impl<'a, ___E>
2142 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
2143 for &'a CapabilityStoreDictionaryCopyRequest
2144 where
2145 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2146 {
2147 #[inline]
2148 fn encode(
2149 self,
2150 encoder_: &mut ___E,
2151 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
2152 _: (),
2153 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2154 ::fidl_next::munge! {
2155 let crate::wire::CapabilityStoreDictionaryCopyRequest {
2156 id,
2157 dest_id,
2158
2159 } = out_;
2160 }
2161
2162 ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
2163
2164 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2165
2166 ::fidl_next::Encode::encode(&self.dest_id, encoder_, dest_id, ())?;
2167
2168 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
2169
2170 Ok(())
2171 }
2172 }
2173
2174 unsafe impl<___E>
2175 ::fidl_next::EncodeOption<
2176 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
2177 ___E,
2178 > for CapabilityStoreDictionaryCopyRequest
2179 where
2180 ___E: ::fidl_next::Encoder + ?Sized,
2181 CapabilityStoreDictionaryCopyRequest:
2182 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>,
2183 {
2184 #[inline]
2185 fn encode_option(
2186 this: ::core::option::Option<Self>,
2187 encoder: &mut ___E,
2188 out: &mut ::core::mem::MaybeUninit<
2189 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
2190 >,
2191 _: (),
2192 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2193 if let Some(inner) = this {
2194 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2195 ::fidl_next::wire::Box::encode_present(out);
2196 } else {
2197 ::fidl_next::wire::Box::encode_absent(out);
2198 }
2199
2200 Ok(())
2201 }
2202 }
2203
2204 unsafe impl<'a, ___E>
2205 ::fidl_next::EncodeOption<
2206 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
2207 ___E,
2208 > for &'a CapabilityStoreDictionaryCopyRequest
2209 where
2210 ___E: ::fidl_next::Encoder + ?Sized,
2211 &'a CapabilityStoreDictionaryCopyRequest:
2212 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>,
2213 {
2214 #[inline]
2215 fn encode_option(
2216 this: ::core::option::Option<Self>,
2217 encoder: &mut ___E,
2218 out: &mut ::core::mem::MaybeUninit<
2219 ::fidl_next::wire::Box<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>,
2220 >,
2221 _: (),
2222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2223 if let Some(inner) = this {
2224 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2225 ::fidl_next::wire::Box::encode_present(out);
2226 } else {
2227 ::fidl_next::wire::Box::encode_absent(out);
2228 }
2229
2230 Ok(())
2231 }
2232 }
2233
2234 impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyRequest>
2235 for CapabilityStoreDictionaryCopyRequest
2236 {
2237 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2238 crate::wire::CapabilityStoreDictionaryCopyRequest,
2239 Self,
2240 > = unsafe {
2241 ::fidl_next::CopyOptimization::enable_if(
2242 true
2243 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
2244 .is_enabled()
2245 && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
2246 .is_enabled(),
2247 )
2248 };
2249
2250 #[inline]
2251 fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
2252 Self {
2253 id: ::fidl_next::FromWire::from_wire(wire.id),
2254
2255 dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
2256 }
2257 }
2258 }
2259
2260 impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyRequest>
2261 for CapabilityStoreDictionaryCopyRequest
2262 {
2263 #[inline]
2264 fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
2265 Self {
2266 id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
2267
2268 dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
2269 }
2270 }
2271 }
2272
2273 pub type CapabilityStoreDictionaryCopyResponse = ();
2274
2275 pub type CapabilityStoreDictionaryKeysResponse = ();
2276
2277 pub type CapabilityStoreDictionaryEnumerateResponse = ();
2278
2279 pub type CapabilityStoreDictionaryDrainResponse = ();
2280
2281 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2282 #[repr(u32)]
2283 pub enum RouterError {
2284 NotFound = 1,
2285 InvalidArgs = 2,
2286 NotSupported = 3,
2287 Internal = 4,
2288 UnknownOrdinal_(u32) = 5,
2289 }
2290 impl ::std::convert::From<u32> for RouterError {
2291 fn from(value: u32) -> Self {
2292 match value {
2293 1 => Self::NotFound,
2294 2 => Self::InvalidArgs,
2295 3 => Self::NotSupported,
2296 4 => Self::Internal,
2297
2298 _ => Self::UnknownOrdinal_(value),
2299 }
2300 }
2301 }
2302
2303 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RouterError, ___E> for RouterError
2304 where
2305 ___E: ?Sized,
2306 {
2307 #[inline]
2308 fn encode(
2309 self,
2310 encoder: &mut ___E,
2311 out: &mut ::core::mem::MaybeUninit<crate::wire::RouterError>,
2312 _: (),
2313 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2314 ::fidl_next::Encode::encode(&self, encoder, out, ())
2315 }
2316 }
2317
2318 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RouterError, ___E> for &'a RouterError
2319 where
2320 ___E: ?Sized,
2321 {
2322 #[inline]
2323 fn encode(
2324 self,
2325 encoder: &mut ___E,
2326 out: &mut ::core::mem::MaybeUninit<crate::wire::RouterError>,
2327 _: (),
2328 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2329 ::fidl_next::munge!(let crate::wire::RouterError { value } = out);
2330 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2331 RouterError::NotFound => 1,
2332
2333 RouterError::InvalidArgs => 2,
2334
2335 RouterError::NotSupported => 3,
2336
2337 RouterError::Internal => 4,
2338
2339 RouterError::UnknownOrdinal_(value) => value,
2340 }));
2341
2342 Ok(())
2343 }
2344 }
2345
2346 impl ::core::convert::From<crate::wire::RouterError> for RouterError {
2347 fn from(wire: crate::wire::RouterError) -> Self {
2348 match u32::from(wire.value) {
2349 1 => Self::NotFound,
2350
2351 2 => Self::InvalidArgs,
2352
2353 3 => Self::NotSupported,
2354
2355 4 => Self::Internal,
2356
2357 value => Self::UnknownOrdinal_(value),
2358 }
2359 }
2360 }
2361
2362 impl ::fidl_next::FromWire<crate::wire::RouterError> for RouterError {
2363 #[inline]
2364 fn from_wire(wire: crate::wire::RouterError) -> Self {
2365 Self::from(wire)
2366 }
2367 }
2368
2369 impl ::fidl_next::FromWireRef<crate::wire::RouterError> for RouterError {
2370 #[inline]
2371 fn from_wire_ref(wire: &crate::wire::RouterError) -> Self {
2372 Self::from(*wire)
2373 }
2374 }
2375
2376 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2377 pub struct DictionaryDrainIteratorGetNextRequest {
2378 pub start_id: u64,
2379
2380 pub limit: u32,
2381 }
2382
2383 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
2384 for DictionaryDrainIteratorGetNextRequest
2385 where
2386 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2387 {
2388 #[inline]
2389 fn encode(
2390 self,
2391 encoder_: &mut ___E,
2392 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
2393 _: (),
2394 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2395 ::fidl_next::munge! {
2396 let crate::wire::DictionaryDrainIteratorGetNextRequest {
2397 start_id,
2398 limit,
2399
2400 } = out_;
2401 }
2402
2403 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
2404
2405 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
2406
2407 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
2408
2409 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
2410
2411 Ok(())
2412 }
2413 }
2414
2415 unsafe impl<'a, ___E>
2416 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
2417 for &'a DictionaryDrainIteratorGetNextRequest
2418 where
2419 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2420 {
2421 #[inline]
2422 fn encode(
2423 self,
2424 encoder_: &mut ___E,
2425 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
2426 _: (),
2427 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2428 ::fidl_next::munge! {
2429 let crate::wire::DictionaryDrainIteratorGetNextRequest {
2430 start_id,
2431 limit,
2432
2433 } = out_;
2434 }
2435
2436 ::fidl_next::Encode::encode(&self.start_id, encoder_, start_id, ())?;
2437
2438 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
2439
2440 ::fidl_next::Encode::encode(&self.limit, encoder_, limit, ())?;
2441
2442 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
2443
2444 Ok(())
2445 }
2446 }
2447
2448 unsafe impl<___E>
2449 ::fidl_next::EncodeOption<
2450 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
2451 ___E,
2452 > for DictionaryDrainIteratorGetNextRequest
2453 where
2454 ___E: ::fidl_next::Encoder + ?Sized,
2455 DictionaryDrainIteratorGetNextRequest:
2456 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>,
2457 {
2458 #[inline]
2459 fn encode_option(
2460 this: ::core::option::Option<Self>,
2461 encoder: &mut ___E,
2462 out: &mut ::core::mem::MaybeUninit<
2463 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
2464 >,
2465 _: (),
2466 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2467 if let Some(inner) = this {
2468 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2469 ::fidl_next::wire::Box::encode_present(out);
2470 } else {
2471 ::fidl_next::wire::Box::encode_absent(out);
2472 }
2473
2474 Ok(())
2475 }
2476 }
2477
2478 unsafe impl<'a, ___E>
2479 ::fidl_next::EncodeOption<
2480 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
2481 ___E,
2482 > for &'a DictionaryDrainIteratorGetNextRequest
2483 where
2484 ___E: ::fidl_next::Encoder + ?Sized,
2485 &'a DictionaryDrainIteratorGetNextRequest:
2486 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>,
2487 {
2488 #[inline]
2489 fn encode_option(
2490 this: ::core::option::Option<Self>,
2491 encoder: &mut ___E,
2492 out: &mut ::core::mem::MaybeUninit<
2493 ::fidl_next::wire::Box<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>,
2494 >,
2495 _: (),
2496 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2497 if let Some(inner) = this {
2498 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2499 ::fidl_next::wire::Box::encode_present(out);
2500 } else {
2501 ::fidl_next::wire::Box::encode_absent(out);
2502 }
2503
2504 Ok(())
2505 }
2506 }
2507
2508 impl ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextRequest>
2509 for DictionaryDrainIteratorGetNextRequest
2510 {
2511 #[inline]
2512 fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
2513 Self {
2514 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
2515
2516 limit: ::fidl_next::FromWire::from_wire(wire.limit),
2517 }
2518 }
2519 }
2520
2521 impl ::fidl_next::FromWireRef<crate::wire::DictionaryDrainIteratorGetNextRequest>
2522 for DictionaryDrainIteratorGetNextRequest
2523 {
2524 #[inline]
2525 fn from_wire_ref(wire: &crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
2526 Self {
2527 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
2528
2529 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
2530 }
2531 }
2532 }
2533
2534 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2535 pub struct DictionaryEnumerateIteratorGetNextRequest {
2536 pub start_id: u64,
2537
2538 pub limit: u32,
2539 }
2540
2541 unsafe impl<___E>
2542 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
2543 for DictionaryEnumerateIteratorGetNextRequest
2544 where
2545 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2546 {
2547 #[inline]
2548 fn encode(
2549 self,
2550 encoder_: &mut ___E,
2551 out_: &mut ::core::mem::MaybeUninit<
2552 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
2553 >,
2554 _: (),
2555 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2556 ::fidl_next::munge! {
2557 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
2558 start_id,
2559 limit,
2560
2561 } = out_;
2562 }
2563
2564 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
2565
2566 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
2567
2568 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
2569
2570 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
2571
2572 Ok(())
2573 }
2574 }
2575
2576 unsafe impl<'a, ___E>
2577 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
2578 for &'a DictionaryEnumerateIteratorGetNextRequest
2579 where
2580 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2581 {
2582 #[inline]
2583 fn encode(
2584 self,
2585 encoder_: &mut ___E,
2586 out_: &mut ::core::mem::MaybeUninit<
2587 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
2588 >,
2589 _: (),
2590 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2591 ::fidl_next::munge! {
2592 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
2593 start_id,
2594 limit,
2595
2596 } = out_;
2597 }
2598
2599 ::fidl_next::Encode::encode(&self.start_id, encoder_, start_id, ())?;
2600
2601 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
2602
2603 ::fidl_next::Encode::encode(&self.limit, encoder_, limit, ())?;
2604
2605 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
2606
2607 Ok(())
2608 }
2609 }
2610
2611 unsafe impl<___E>
2612 ::fidl_next::EncodeOption<
2613 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>,
2614 ___E,
2615 > for DictionaryEnumerateIteratorGetNextRequest
2616 where
2617 ___E: ::fidl_next::Encoder + ?Sized,
2618 DictionaryEnumerateIteratorGetNextRequest:
2619 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>,
2620 {
2621 #[inline]
2622 fn encode_option(
2623 this: ::core::option::Option<Self>,
2624 encoder: &mut ___E,
2625 out: &mut ::core::mem::MaybeUninit<
2626 ::fidl_next::wire::Box<
2627 'static,
2628 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
2629 >,
2630 >,
2631 _: (),
2632 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2633 if let Some(inner) = this {
2634 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2635 ::fidl_next::wire::Box::encode_present(out);
2636 } else {
2637 ::fidl_next::wire::Box::encode_absent(out);
2638 }
2639
2640 Ok(())
2641 }
2642 }
2643
2644 unsafe impl<'a, ___E>
2645 ::fidl_next::EncodeOption<
2646 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>,
2647 ___E,
2648 > for &'a DictionaryEnumerateIteratorGetNextRequest
2649 where
2650 ___E: ::fidl_next::Encoder + ?Sized,
2651 &'a DictionaryEnumerateIteratorGetNextRequest:
2652 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>,
2653 {
2654 #[inline]
2655 fn encode_option(
2656 this: ::core::option::Option<Self>,
2657 encoder: &mut ___E,
2658 out: &mut ::core::mem::MaybeUninit<
2659 ::fidl_next::wire::Box<
2660 'static,
2661 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
2662 >,
2663 >,
2664 _: (),
2665 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2666 if let Some(inner) = this {
2667 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2668 ::fidl_next::wire::Box::encode_present(out);
2669 } else {
2670 ::fidl_next::wire::Box::encode_absent(out);
2671 }
2672
2673 Ok(())
2674 }
2675 }
2676
2677 impl ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
2678 for DictionaryEnumerateIteratorGetNextRequest
2679 {
2680 #[inline]
2681 fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
2682 Self {
2683 start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
2684
2685 limit: ::fidl_next::FromWire::from_wire(wire.limit),
2686 }
2687 }
2688 }
2689
2690 impl ::fidl_next::FromWireRef<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
2691 for DictionaryEnumerateIteratorGetNextRequest
2692 {
2693 #[inline]
2694 fn from_wire_ref(wire: &crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
2695 Self {
2696 start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
2697
2698 limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
2699 }
2700 }
2701 }
2702
2703 #[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
2704 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2705 #[repr(u32)]
2706 pub enum DictionaryError {
2707 NotFound = 1,
2708 AlreadyExists = 2,
2709 BadCapability = 3,
2710 InvalidKey = 4,
2711 NotCloneable = 5,
2712 UnknownOrdinal_(u32) = 6,
2713 }
2714 impl ::std::convert::From<u32> for DictionaryError {
2715 fn from(value: u32) -> Self {
2716 match value {
2717 1 => Self::NotFound,
2718 2 => Self::AlreadyExists,
2719 3 => Self::BadCapability,
2720 4 => Self::InvalidKey,
2721 5 => Self::NotCloneable,
2722
2723 _ => Self::UnknownOrdinal_(value),
2724 }
2725 }
2726 }
2727
2728 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryError, ___E> for DictionaryError
2729 where
2730 ___E: ?Sized,
2731 {
2732 #[inline]
2733 fn encode(
2734 self,
2735 encoder: &mut ___E,
2736 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryError>,
2737 _: (),
2738 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2739 ::fidl_next::Encode::encode(&self, encoder, out, ())
2740 }
2741 }
2742
2743 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryError, ___E>
2744 for &'a DictionaryError
2745 where
2746 ___E: ?Sized,
2747 {
2748 #[inline]
2749 fn encode(
2750 self,
2751 encoder: &mut ___E,
2752 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryError>,
2753 _: (),
2754 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2755 ::fidl_next::munge!(let crate::wire::DictionaryError { value } = out);
2756 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2757 DictionaryError::NotFound => 1,
2758
2759 DictionaryError::AlreadyExists => 2,
2760
2761 DictionaryError::BadCapability => 3,
2762
2763 DictionaryError::InvalidKey => 4,
2764
2765 DictionaryError::NotCloneable => 5,
2766
2767 DictionaryError::UnknownOrdinal_(value) => value,
2768 }));
2769
2770 Ok(())
2771 }
2772 }
2773
2774 impl ::core::convert::From<crate::wire::DictionaryError> for DictionaryError {
2775 fn from(wire: crate::wire::DictionaryError) -> Self {
2776 match u32::from(wire.value) {
2777 1 => Self::NotFound,
2778
2779 2 => Self::AlreadyExists,
2780
2781 3 => Self::BadCapability,
2782
2783 4 => Self::InvalidKey,
2784
2785 5 => Self::NotCloneable,
2786
2787 value => Self::UnknownOrdinal_(value),
2788 }
2789 }
2790 }
2791
2792 impl ::fidl_next::FromWire<crate::wire::DictionaryError> for DictionaryError {
2793 #[inline]
2794 fn from_wire(wire: crate::wire::DictionaryError) -> Self {
2795 Self::from(wire)
2796 }
2797 }
2798
2799 impl ::fidl_next::FromWireRef<crate::wire::DictionaryError> for DictionaryError {
2800 #[inline]
2801 fn from_wire_ref(wire: &crate::wire::DictionaryError) -> Self {
2802 Self::from(*wire)
2803 }
2804 }
2805
2806 pub type Unavailable = ();
2807}
2808
2809pub mod wire {
2810
2811 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
2813 #[repr(transparent)]
2814 pub struct Availability {
2815 pub(crate) value: ::fidl_next::wire::Uint32,
2816 }
2817
2818 impl ::fidl_next::Constrained for Availability {
2819 type Constraint = ();
2820
2821 fn validate(
2822 _: ::fidl_next::Slot<'_, Self>,
2823 _: Self::Constraint,
2824 ) -> Result<(), ::fidl_next::ValidationError> {
2825 Ok(())
2826 }
2827 }
2828
2829 unsafe impl ::fidl_next::Wire for Availability {
2830 type Narrowed<'de> = Self;
2831
2832 #[inline]
2833 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2834 }
2836 }
2837
2838 impl Availability {
2839 pub const REQUIRED: Availability = Availability { value: ::fidl_next::wire::Uint32(1) };
2840
2841 pub const OPTIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(2) };
2842
2843 pub const SAME_AS_TARGET: Availability =
2844 Availability { value: ::fidl_next::wire::Uint32(3) };
2845
2846 pub const TRANSITIONAL: Availability = Availability { value: ::fidl_next::wire::Uint32(4) };
2847 }
2848
2849 unsafe impl<___D> ::fidl_next::Decode<___D> for Availability
2850 where
2851 ___D: ?Sized,
2852 {
2853 fn decode(
2854 slot: ::fidl_next::Slot<'_, Self>,
2855 _: &mut ___D,
2856 _: (),
2857 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2858 ::fidl_next::munge!(let Self { value } = slot);
2859
2860 match u32::from(*value) {
2861 1 | 2 | 3 | 4 => (),
2862 unknown => {
2863 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
2864 }
2865 }
2866
2867 Ok(())
2868 }
2869 }
2870
2871 impl ::core::convert::From<crate::natural::Availability> for Availability {
2872 fn from(natural: crate::natural::Availability) -> Self {
2873 match natural {
2874 crate::natural::Availability::Required => Availability::REQUIRED,
2875
2876 crate::natural::Availability::Optional => Availability::OPTIONAL,
2877
2878 crate::natural::Availability::SameAsTarget => Availability::SAME_AS_TARGET,
2879
2880 crate::natural::Availability::Transitional => Availability::TRANSITIONAL,
2881 }
2882 }
2883 }
2884
2885 impl ::fidl_next::IntoNatural for Availability {
2886 type Natural = crate::natural::Availability;
2887 }
2888
2889 pub type Unit = ::fidl_next::wire::Unit;
2891
2892 #[repr(transparent)]
2894 pub struct Data<'de> {
2895 pub(crate) raw: ::fidl_next::wire::Union,
2896 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2897 }
2898
2899 impl<'de> Drop for Data<'de> {
2900 fn drop(&mut self) {
2901 match self.raw.ordinal() {
2902 1 => {
2903 let _ = unsafe {
2904 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2905 };
2906 }
2907
2908 2 => {
2909 let _ = unsafe {
2910 self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
2911 };
2912 }
2913
2914 3 => {
2915 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Int64>() };
2916 }
2917
2918 4 => {
2919 let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::wire::Uint64>() };
2920 }
2921
2922 _ => (),
2923 }
2924 }
2925 }
2926
2927 impl ::fidl_next::Constrained for Data<'_> {
2928 type Constraint = ();
2929
2930 fn validate(
2931 _: ::fidl_next::Slot<'_, Self>,
2932 _: Self::Constraint,
2933 ) -> Result<(), ::fidl_next::ValidationError> {
2934 Ok(())
2935 }
2936 }
2937
2938 unsafe impl ::fidl_next::Wire for Data<'static> {
2939 type Narrowed<'de> = Data<'de>;
2940
2941 #[inline]
2942 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2943 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2944 ::fidl_next::wire::Union::zero_padding(raw);
2945 }
2946 }
2947
2948 pub mod data {
2949 pub enum Ref<'de> {
2950 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
2951
2952 String(&'de ::fidl_next::wire::String<'de>),
2953
2954 Int64(&'de ::fidl_next::wire::Int64),
2955
2956 Uint64(&'de ::fidl_next::wire::Uint64),
2957
2958 UnknownOrdinal_(u64),
2959 }
2960 }
2961
2962 impl<'de> Data<'de> {
2963 pub fn as_ref(&self) -> crate::wire::data::Ref<'_> {
2964 match self.raw.ordinal() {
2965 1 => crate::wire::data::Ref::Bytes(unsafe {
2966 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
2967 }),
2968
2969 2 => crate::wire::data::Ref::String(unsafe {
2970 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
2971 }),
2972
2973 3 => crate::wire::data::Ref::Int64(unsafe {
2974 self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>()
2975 }),
2976
2977 4 => crate::wire::data::Ref::Uint64(unsafe {
2978 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>()
2979 }),
2980
2981 unknown => crate::wire::data::Ref::UnknownOrdinal_(unknown),
2982 }
2983 }
2984 }
2985
2986 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Data<'de>
2987 where
2988 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2989 ___D: ::fidl_next::Decoder<'de>,
2990 {
2991 fn decode(
2992 mut slot: ::fidl_next::Slot<'_, Self>,
2993 decoder: &mut ___D,
2994 _: (),
2995 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2996 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2997 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
2998 1 => {
2999 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
3000 raw,
3001 decoder,
3002 (8192, ()),
3003 )?
3004 }
3005
3006 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
3007 raw, decoder, 8192,
3008 )?,
3009
3010 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
3011 raw,
3012 decoder,
3013 (),
3014 )?,
3015
3016 4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
3017 raw,
3018 decoder,
3019 (),
3020 )?,
3021
3022 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3023 }
3024
3025 Ok(())
3026 }
3027 }
3028
3029 impl<'de> ::core::fmt::Debug for Data<'de> {
3030 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3031 match self.raw.ordinal() {
3032 1 => unsafe {
3033 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
3034 },
3035 2 => unsafe {
3036 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
3037 },
3038 3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::wire::Int64>().fmt(f) },
3039 4 => unsafe {
3040 self.raw.get().deref_unchecked::<::fidl_next::wire::Uint64>().fmt(f)
3041 },
3042 _ => unsafe { ::core::hint::unreachable_unchecked() },
3043 }
3044 }
3045 }
3046
3047 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
3048 type Natural = crate::natural::Data;
3049 }
3050
3051 pub type CapabilityId = ::fidl_next::wire::Uint64;
3053
3054 pub type NewCapabilityId = ::fidl_next::wire::Uint64;
3056
3057 #[derive(Clone, Debug)]
3059 #[repr(C)]
3060 pub struct CapabilityStoreDuplicateRequest {
3061 pub id: ::fidl_next::wire::Uint64,
3062
3063 pub dest_id: ::fidl_next::wire::Uint64,
3064 }
3065
3066 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateRequest>(), 16);
3067 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDuplicateRequest>(), 8);
3068
3069 static_assertions::const_assert_eq!(
3070 std::mem::offset_of!(CapabilityStoreDuplicateRequest, id),
3071 0
3072 );
3073
3074 static_assertions::const_assert_eq!(
3075 std::mem::offset_of!(CapabilityStoreDuplicateRequest, dest_id),
3076 8
3077 );
3078
3079 impl ::fidl_next::Constrained for CapabilityStoreDuplicateRequest {
3080 type Constraint = ();
3081
3082 fn validate(
3083 _: ::fidl_next::Slot<'_, Self>,
3084 _: Self::Constraint,
3085 ) -> Result<(), ::fidl_next::ValidationError> {
3086 Ok(())
3087 }
3088 }
3089
3090 unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateRequest {
3091 type Narrowed<'de> = CapabilityStoreDuplicateRequest;
3092
3093 #[inline]
3094 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3095 ::fidl_next::munge! {
3096 let Self {
3097 id,
3098 dest_id,
3099
3100 } = &mut *out_;
3101 }
3102
3103 ::fidl_next::Wire::zero_padding(id);
3104
3105 ::fidl_next::Wire::zero_padding(dest_id);
3106 }
3107 }
3108
3109 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateRequest
3110 where
3111 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3112 {
3113 fn decode(
3114 slot_: ::fidl_next::Slot<'_, Self>,
3115 decoder_: &mut ___D,
3116 _: (),
3117 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3118 ::fidl_next::munge! {
3119 let Self {
3120 mut id,
3121 mut dest_id,
3122
3123 } = slot_;
3124 }
3125
3126 let _field = id.as_mut();
3127
3128 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3129
3130 let _field = dest_id.as_mut();
3131
3132 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
3133
3134 Ok(())
3135 }
3136 }
3137
3138 impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateRequest {
3139 type Natural = crate::natural::CapabilityStoreDuplicateRequest;
3140 }
3141
3142 pub type CapabilityStoreDuplicateResponse = ::fidl_next::wire::Unit;
3144
3145 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3147 #[repr(transparent)]
3148 pub struct CapabilityStoreError {
3149 pub(crate) value: ::fidl_next::wire::Uint32,
3150 }
3151
3152 impl ::fidl_next::Constrained for CapabilityStoreError {
3153 type Constraint = ();
3154
3155 fn validate(
3156 _: ::fidl_next::Slot<'_, Self>,
3157 _: Self::Constraint,
3158 ) -> Result<(), ::fidl_next::ValidationError> {
3159 Ok(())
3160 }
3161 }
3162
3163 unsafe impl ::fidl_next::Wire for CapabilityStoreError {
3164 type Narrowed<'de> = Self;
3165
3166 #[inline]
3167 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3168 }
3170 }
3171
3172 impl CapabilityStoreError {
3173 pub const ID_NOT_FOUND: CapabilityStoreError =
3174 CapabilityStoreError { value: ::fidl_next::wire::Uint32(1) };
3175
3176 pub const ID_ALREADY_EXISTS: CapabilityStoreError =
3177 CapabilityStoreError { value: ::fidl_next::wire::Uint32(2) };
3178
3179 pub const BAD_CAPABILITY: CapabilityStoreError =
3180 CapabilityStoreError { value: ::fidl_next::wire::Uint32(3) };
3181
3182 pub const WRONG_TYPE: CapabilityStoreError =
3183 CapabilityStoreError { value: ::fidl_next::wire::Uint32(4) };
3184
3185 pub const NOT_DUPLICATABLE: CapabilityStoreError =
3186 CapabilityStoreError { value: ::fidl_next::wire::Uint32(5) };
3187
3188 pub const ITEM_NOT_FOUND: CapabilityStoreError =
3189 CapabilityStoreError { value: ::fidl_next::wire::Uint32(6) };
3190
3191 pub const ITEM_ALREADY_EXISTS: CapabilityStoreError =
3192 CapabilityStoreError { value: ::fidl_next::wire::Uint32(7) };
3193
3194 pub const INVALID_KEY: CapabilityStoreError =
3195 CapabilityStoreError { value: ::fidl_next::wire::Uint32(8) };
3196
3197 pub const INVALID_ARGS: CapabilityStoreError =
3198 CapabilityStoreError { value: ::fidl_next::wire::Uint32(9) };
3199 }
3200
3201 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreError
3202 where
3203 ___D: ?Sized,
3204 {
3205 fn decode(
3206 slot: ::fidl_next::Slot<'_, Self>,
3207 _: &mut ___D,
3208 _: (),
3209 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3210 Ok(())
3211 }
3212 }
3213
3214 impl ::core::convert::From<crate::natural::CapabilityStoreError> for CapabilityStoreError {
3215 fn from(natural: crate::natural::CapabilityStoreError) -> Self {
3216 match natural {
3217 crate::natural::CapabilityStoreError::IdNotFound => {
3218 CapabilityStoreError::ID_NOT_FOUND
3219 }
3220
3221 crate::natural::CapabilityStoreError::IdAlreadyExists => {
3222 CapabilityStoreError::ID_ALREADY_EXISTS
3223 }
3224
3225 crate::natural::CapabilityStoreError::BadCapability => {
3226 CapabilityStoreError::BAD_CAPABILITY
3227 }
3228
3229 crate::natural::CapabilityStoreError::WrongType => CapabilityStoreError::WRONG_TYPE,
3230
3231 crate::natural::CapabilityStoreError::NotDuplicatable => {
3232 CapabilityStoreError::NOT_DUPLICATABLE
3233 }
3234
3235 crate::natural::CapabilityStoreError::ItemNotFound => {
3236 CapabilityStoreError::ITEM_NOT_FOUND
3237 }
3238
3239 crate::natural::CapabilityStoreError::ItemAlreadyExists => {
3240 CapabilityStoreError::ITEM_ALREADY_EXISTS
3241 }
3242
3243 crate::natural::CapabilityStoreError::InvalidKey => {
3244 CapabilityStoreError::INVALID_KEY
3245 }
3246
3247 crate::natural::CapabilityStoreError::InvalidArgs => {
3248 CapabilityStoreError::INVALID_ARGS
3249 }
3250
3251 crate::natural::CapabilityStoreError::UnknownOrdinal_(value) => {
3252 CapabilityStoreError { value: ::fidl_next::wire::Uint32::from(value) }
3253 }
3254 }
3255 }
3256 }
3257
3258 impl ::fidl_next::IntoNatural for CapabilityStoreError {
3259 type Natural = crate::natural::CapabilityStoreError;
3260 }
3261
3262 #[derive(Clone, Debug)]
3264 #[repr(C)]
3265 pub struct CapabilityStoreDropRequest {
3266 pub id: ::fidl_next::wire::Uint64,
3267 }
3268
3269 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropRequest>(), 8);
3270 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropRequest>(), 8);
3271
3272 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreDropRequest, id), 0);
3273
3274 impl ::fidl_next::Constrained for CapabilityStoreDropRequest {
3275 type Constraint = ();
3276
3277 fn validate(
3278 _: ::fidl_next::Slot<'_, Self>,
3279 _: Self::Constraint,
3280 ) -> Result<(), ::fidl_next::ValidationError> {
3281 Ok(())
3282 }
3283 }
3284
3285 unsafe impl ::fidl_next::Wire for CapabilityStoreDropRequest {
3286 type Narrowed<'de> = CapabilityStoreDropRequest;
3287
3288 #[inline]
3289 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3290 ::fidl_next::munge! {
3291 let Self {
3292 id,
3293
3294 } = &mut *out_;
3295 }
3296
3297 ::fidl_next::Wire::zero_padding(id);
3298 }
3299 }
3300
3301 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropRequest
3302 where
3303 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3304 {
3305 fn decode(
3306 slot_: ::fidl_next::Slot<'_, Self>,
3307 decoder_: &mut ___D,
3308 _: (),
3309 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3310 ::fidl_next::munge! {
3311 let Self {
3312 mut id,
3313
3314 } = slot_;
3315 }
3316
3317 let _field = id.as_mut();
3318
3319 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3320
3321 Ok(())
3322 }
3323 }
3324
3325 impl ::fidl_next::IntoNatural for CapabilityStoreDropRequest {
3326 type Natural = crate::natural::CapabilityStoreDropRequest;
3327 }
3328
3329 pub type CapabilityStoreDropResponse = ::fidl_next::wire::Unit;
3331
3332 #[derive(Clone, Debug)]
3334 #[repr(C)]
3335 pub struct CapabilityStoreExportRequest {
3336 pub id: ::fidl_next::wire::Uint64,
3337 }
3338
3339 static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreExportRequest>(), 8);
3340 static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreExportRequest>(), 8);
3341
3342 static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreExportRequest, id), 0);
3343
3344 impl ::fidl_next::Constrained for CapabilityStoreExportRequest {
3345 type Constraint = ();
3346
3347 fn validate(
3348 _: ::fidl_next::Slot<'_, Self>,
3349 _: Self::Constraint,
3350 ) -> Result<(), ::fidl_next::ValidationError> {
3351 Ok(())
3352 }
3353 }
3354
3355 unsafe impl ::fidl_next::Wire for CapabilityStoreExportRequest {
3356 type Narrowed<'de> = CapabilityStoreExportRequest;
3357
3358 #[inline]
3359 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3360 ::fidl_next::munge! {
3361 let Self {
3362 id,
3363
3364 } = &mut *out_;
3365 }
3366
3367 ::fidl_next::Wire::zero_padding(id);
3368 }
3369 }
3370
3371 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportRequest
3372 where
3373 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3374 {
3375 fn decode(
3376 slot_: ::fidl_next::Slot<'_, Self>,
3377 decoder_: &mut ___D,
3378 _: (),
3379 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3380 ::fidl_next::munge! {
3381 let Self {
3382 mut id,
3383
3384 } = slot_;
3385 }
3386
3387 let _field = id.as_mut();
3388
3389 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3390
3391 Ok(())
3392 }
3393 }
3394
3395 impl ::fidl_next::IntoNatural for CapabilityStoreExportRequest {
3396 type Natural = crate::natural::CapabilityStoreExportRequest;
3397 }
3398
3399 pub type CapabilityStoreImportResponse = ::fidl_next::wire::Unit;
3401
3402 pub type CapabilityStoreConnectorCreateResponse = ::fidl_next::wire::Unit;
3404
3405 pub type CapabilityStoreConnectorOpenResponse = ::fidl_next::wire::Unit;
3407
3408 pub type CapabilityStoreDirConnectorCreateResponse = ::fidl_next::wire::Unit;
3410
3411 pub type CapabilityStoreDirConnectorOpenResponse = ::fidl_next::wire::Unit;
3413
3414 #[derive(Clone, Debug)]
3416 #[repr(C)]
3417 pub struct CapabilityStoreDictionaryCreateRequest {
3418 pub id: ::fidl_next::wire::Uint64,
3419 }
3420
3421 static_assertions::const_assert_eq!(
3422 std::mem::size_of::<CapabilityStoreDictionaryCreateRequest>(),
3423 8
3424 );
3425 static_assertions::const_assert_eq!(
3426 std::mem::align_of::<CapabilityStoreDictionaryCreateRequest>(),
3427 8
3428 );
3429
3430 static_assertions::const_assert_eq!(
3431 std::mem::offset_of!(CapabilityStoreDictionaryCreateRequest, id),
3432 0
3433 );
3434
3435 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCreateRequest {
3436 type Constraint = ();
3437
3438 fn validate(
3439 _: ::fidl_next::Slot<'_, Self>,
3440 _: Self::Constraint,
3441 ) -> Result<(), ::fidl_next::ValidationError> {
3442 Ok(())
3443 }
3444 }
3445
3446 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateRequest {
3447 type Narrowed<'de> = CapabilityStoreDictionaryCreateRequest;
3448
3449 #[inline]
3450 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3451 ::fidl_next::munge! {
3452 let Self {
3453 id,
3454
3455 } = &mut *out_;
3456 }
3457
3458 ::fidl_next::Wire::zero_padding(id);
3459 }
3460 }
3461
3462 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateRequest
3463 where
3464 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3465 {
3466 fn decode(
3467 slot_: ::fidl_next::Slot<'_, Self>,
3468 decoder_: &mut ___D,
3469 _: (),
3470 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3471 ::fidl_next::munge! {
3472 let Self {
3473 mut id,
3474
3475 } = slot_;
3476 }
3477
3478 let _field = id.as_mut();
3479
3480 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3481
3482 Ok(())
3483 }
3484 }
3485
3486 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateRequest {
3487 type Natural = crate::natural::CapabilityStoreDictionaryCreateRequest;
3488 }
3489
3490 pub type CapabilityStoreDictionaryCreateResponse = ::fidl_next::wire::Unit;
3492
3493 pub type CapabilityStoreDictionaryLegacyImportResponse = ::fidl_next::wire::Unit;
3495
3496 pub type CapabilityStoreDictionaryLegacyExportResponse = ::fidl_next::wire::Unit;
3498
3499 pub type DictionaryKey<'de> = ::fidl_next::wire::String<'de>;
3501
3502 #[derive(Debug)]
3504 #[repr(C)]
3505 pub struct DictionaryItem<'de> {
3506 pub key: ::fidl_next::wire::String<'de>,
3507
3508 pub value: ::fidl_next::wire::Uint64,
3509 }
3510
3511 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryItem<'_>>(), 24);
3512 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryItem<'_>>(), 8);
3513
3514 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, key), 0);
3515
3516 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, value), 16);
3517
3518 impl ::fidl_next::Constrained for DictionaryItem<'_> {
3519 type Constraint = ();
3520
3521 fn validate(
3522 _: ::fidl_next::Slot<'_, Self>,
3523 _: Self::Constraint,
3524 ) -> Result<(), ::fidl_next::ValidationError> {
3525 Ok(())
3526 }
3527 }
3528
3529 unsafe impl ::fidl_next::Wire for DictionaryItem<'static> {
3530 type Narrowed<'de> = DictionaryItem<'de>;
3531
3532 #[inline]
3533 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3534 ::fidl_next::munge! {
3535 let Self {
3536 key,
3537 value,
3538
3539 } = &mut *out_;
3540 }
3541
3542 ::fidl_next::Wire::zero_padding(key);
3543
3544 ::fidl_next::Wire::zero_padding(value);
3545 }
3546 }
3547
3548 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryItem<'de>
3549 where
3550 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3551 ___D: ::fidl_next::Decoder<'de>,
3552 {
3553 fn decode(
3554 slot_: ::fidl_next::Slot<'_, Self>,
3555 decoder_: &mut ___D,
3556 _: (),
3557 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3558 ::fidl_next::munge! {
3559 let Self {
3560 mut key,
3561 mut value,
3562
3563 } = slot_;
3564 }
3565
3566 let _field = key.as_mut();
3567 ::fidl_next::Constrained::validate(_field, 255)?;
3568 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
3569
3570 let key = unsafe { key.deref_unchecked() };
3571
3572 if key.len() > 255 {
3573 return Err(::fidl_next::DecodeError::VectorTooLong {
3574 size: key.len() as u64,
3575 limit: 255,
3576 });
3577 }
3578
3579 let _field = value.as_mut();
3580
3581 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3582
3583 Ok(())
3584 }
3585 }
3586
3587 impl<'de> ::fidl_next::IntoNatural for DictionaryItem<'de> {
3588 type Natural = crate::natural::DictionaryItem;
3589 }
3590
3591 #[derive(Debug)]
3593 #[repr(C)]
3594 pub struct CapabilityStoreDictionaryInsertRequest<'de> {
3595 pub id: ::fidl_next::wire::Uint64,
3596
3597 pub item: crate::wire::DictionaryItem<'de>,
3598 }
3599
3600 static_assertions::const_assert_eq!(
3601 std::mem::size_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
3602 32
3603 );
3604 static_assertions::const_assert_eq!(
3605 std::mem::align_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
3606 8
3607 );
3608
3609 static_assertions::const_assert_eq!(
3610 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, id),
3611 0
3612 );
3613
3614 static_assertions::const_assert_eq!(
3615 std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, item),
3616 8
3617 );
3618
3619 impl ::fidl_next::Constrained for CapabilityStoreDictionaryInsertRequest<'_> {
3620 type Constraint = ();
3621
3622 fn validate(
3623 _: ::fidl_next::Slot<'_, Self>,
3624 _: Self::Constraint,
3625 ) -> Result<(), ::fidl_next::ValidationError> {
3626 Ok(())
3627 }
3628 }
3629
3630 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertRequest<'static> {
3631 type Narrowed<'de> = CapabilityStoreDictionaryInsertRequest<'de>;
3632
3633 #[inline]
3634 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3635 ::fidl_next::munge! {
3636 let Self {
3637 id,
3638 item,
3639
3640 } = &mut *out_;
3641 }
3642
3643 ::fidl_next::Wire::zero_padding(id);
3644
3645 ::fidl_next::Wire::zero_padding(item);
3646 }
3647 }
3648
3649 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertRequest<'de>
3650 where
3651 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3652 ___D: ::fidl_next::Decoder<'de>,
3653 {
3654 fn decode(
3655 slot_: ::fidl_next::Slot<'_, Self>,
3656 decoder_: &mut ___D,
3657 _: (),
3658 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3659 ::fidl_next::munge! {
3660 let Self {
3661 mut id,
3662 mut item,
3663
3664 } = slot_;
3665 }
3666
3667 let _field = id.as_mut();
3668
3669 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3670
3671 let _field = item.as_mut();
3672
3673 ::fidl_next::Decode::decode(item.as_mut(), decoder_, ())?;
3674
3675 Ok(())
3676 }
3677 }
3678
3679 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertRequest<'de> {
3680 type Natural = crate::natural::CapabilityStoreDictionaryInsertRequest;
3681 }
3682
3683 pub type CapabilityStoreDictionaryInsertResponse = ::fidl_next::wire::Unit;
3685
3686 #[derive(Debug)]
3688 #[repr(C)]
3689 pub struct CapabilityStoreDictionaryGetRequest<'de> {
3690 pub id: ::fidl_next::wire::Uint64,
3691
3692 pub key: ::fidl_next::wire::String<'de>,
3693
3694 pub dest_id: ::fidl_next::wire::Uint64,
3695 }
3696
3697 static_assertions::const_assert_eq!(
3698 std::mem::size_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
3699 32
3700 );
3701 static_assertions::const_assert_eq!(
3702 std::mem::align_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
3703 8
3704 );
3705
3706 static_assertions::const_assert_eq!(
3707 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, id),
3708 0
3709 );
3710
3711 static_assertions::const_assert_eq!(
3712 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, key),
3713 8
3714 );
3715
3716 static_assertions::const_assert_eq!(
3717 std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, dest_id),
3718 24
3719 );
3720
3721 impl ::fidl_next::Constrained for CapabilityStoreDictionaryGetRequest<'_> {
3722 type Constraint = ();
3723
3724 fn validate(
3725 _: ::fidl_next::Slot<'_, Self>,
3726 _: Self::Constraint,
3727 ) -> Result<(), ::fidl_next::ValidationError> {
3728 Ok(())
3729 }
3730 }
3731
3732 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetRequest<'static> {
3733 type Narrowed<'de> = CapabilityStoreDictionaryGetRequest<'de>;
3734
3735 #[inline]
3736 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3737 ::fidl_next::munge! {
3738 let Self {
3739 id,
3740 key,
3741 dest_id,
3742
3743 } = &mut *out_;
3744 }
3745
3746 ::fidl_next::Wire::zero_padding(id);
3747
3748 ::fidl_next::Wire::zero_padding(key);
3749
3750 ::fidl_next::Wire::zero_padding(dest_id);
3751 }
3752 }
3753
3754 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetRequest<'de>
3755 where
3756 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3757 ___D: ::fidl_next::Decoder<'de>,
3758 {
3759 fn decode(
3760 slot_: ::fidl_next::Slot<'_, Self>,
3761 decoder_: &mut ___D,
3762 _: (),
3763 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3764 ::fidl_next::munge! {
3765 let Self {
3766 mut id,
3767 mut key,
3768 mut dest_id,
3769
3770 } = slot_;
3771 }
3772
3773 let _field = id.as_mut();
3774
3775 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3776
3777 let _field = key.as_mut();
3778 ::fidl_next::Constrained::validate(_field, 255)?;
3779 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
3780
3781 let key = unsafe { key.deref_unchecked() };
3782
3783 if key.len() > 255 {
3784 return Err(::fidl_next::DecodeError::VectorTooLong {
3785 size: key.len() as u64,
3786 limit: 255,
3787 });
3788 }
3789
3790 let _field = dest_id.as_mut();
3791
3792 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
3793
3794 Ok(())
3795 }
3796 }
3797
3798 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetRequest<'de> {
3799 type Natural = crate::natural::CapabilityStoreDictionaryGetRequest;
3800 }
3801
3802 pub type CapabilityStoreDictionaryGetResponse = ::fidl_next::wire::Unit;
3804
3805 #[derive(Clone, Debug)]
3807 #[repr(C)]
3808 pub struct WrappedCapabilityId {
3809 pub id: ::fidl_next::wire::Uint64,
3810 }
3811
3812 static_assertions::const_assert_eq!(std::mem::size_of::<WrappedCapabilityId>(), 8);
3813 static_assertions::const_assert_eq!(std::mem::align_of::<WrappedCapabilityId>(), 8);
3814
3815 static_assertions::const_assert_eq!(std::mem::offset_of!(WrappedCapabilityId, id), 0);
3816
3817 impl ::fidl_next::Constrained for WrappedCapabilityId {
3818 type Constraint = ();
3819
3820 fn validate(
3821 _: ::fidl_next::Slot<'_, Self>,
3822 _: Self::Constraint,
3823 ) -> Result<(), ::fidl_next::ValidationError> {
3824 Ok(())
3825 }
3826 }
3827
3828 unsafe impl ::fidl_next::Wire for WrappedCapabilityId {
3829 type Narrowed<'de> = WrappedCapabilityId;
3830
3831 #[inline]
3832 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3833 ::fidl_next::munge! {
3834 let Self {
3835 id,
3836
3837 } = &mut *out_;
3838 }
3839
3840 ::fidl_next::Wire::zero_padding(id);
3841 }
3842 }
3843
3844 unsafe impl<___D> ::fidl_next::Decode<___D> for WrappedCapabilityId
3845 where
3846 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3847 {
3848 fn decode(
3849 slot_: ::fidl_next::Slot<'_, Self>,
3850 decoder_: &mut ___D,
3851 _: (),
3852 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3853 ::fidl_next::munge! {
3854 let Self {
3855 mut id,
3856
3857 } = slot_;
3858 }
3859
3860 let _field = id.as_mut();
3861
3862 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3863
3864 Ok(())
3865 }
3866 }
3867
3868 impl ::fidl_next::IntoNatural for WrappedCapabilityId {
3869 type Natural = crate::natural::WrappedCapabilityId;
3870 }
3871
3872 pub type WrappedNewCapabilityId = crate::wire::WrappedCapabilityId;
3874
3875 #[derive(Debug)]
3877 #[repr(C)]
3878 pub struct CapabilityStoreDictionaryRemoveRequest<'de> {
3879 pub id: ::fidl_next::wire::Uint64,
3880
3881 pub key: ::fidl_next::wire::String<'de>,
3882
3883 pub dest_id: ::fidl_next::wire::Box<'de, crate::wire::WrappedCapabilityId>,
3884 }
3885
3886 static_assertions::const_assert_eq!(
3887 std::mem::size_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
3888 32
3889 );
3890 static_assertions::const_assert_eq!(
3891 std::mem::align_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
3892 8
3893 );
3894
3895 static_assertions::const_assert_eq!(
3896 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, id),
3897 0
3898 );
3899
3900 static_assertions::const_assert_eq!(
3901 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, key),
3902 8
3903 );
3904
3905 static_assertions::const_assert_eq!(
3906 std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
3907 24
3908 );
3909
3910 impl ::fidl_next::Constrained for CapabilityStoreDictionaryRemoveRequest<'_> {
3911 type Constraint = ();
3912
3913 fn validate(
3914 _: ::fidl_next::Slot<'_, Self>,
3915 _: Self::Constraint,
3916 ) -> Result<(), ::fidl_next::ValidationError> {
3917 Ok(())
3918 }
3919 }
3920
3921 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveRequest<'static> {
3922 type Narrowed<'de> = CapabilityStoreDictionaryRemoveRequest<'de>;
3923
3924 #[inline]
3925 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3926 ::fidl_next::munge! {
3927 let Self {
3928 id,
3929 key,
3930 dest_id,
3931
3932 } = &mut *out_;
3933 }
3934
3935 ::fidl_next::Wire::zero_padding(id);
3936
3937 ::fidl_next::Wire::zero_padding(key);
3938
3939 ::fidl_next::Wire::zero_padding(dest_id);
3940 }
3941 }
3942
3943 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveRequest<'de>
3944 where
3945 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3946 ___D: ::fidl_next::Decoder<'de>,
3947 {
3948 fn decode(
3949 slot_: ::fidl_next::Slot<'_, Self>,
3950 decoder_: &mut ___D,
3951 _: (),
3952 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3953 ::fidl_next::munge! {
3954 let Self {
3955 mut id,
3956 mut key,
3957 mut dest_id,
3958
3959 } = slot_;
3960 }
3961
3962 let _field = id.as_mut();
3963
3964 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
3965
3966 let _field = key.as_mut();
3967 ::fidl_next::Constrained::validate(_field, 255)?;
3968 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
3969
3970 let key = unsafe { key.deref_unchecked() };
3971
3972 if key.len() > 255 {
3973 return Err(::fidl_next::DecodeError::VectorTooLong {
3974 size: key.len() as u64,
3975 limit: 255,
3976 });
3977 }
3978
3979 let _field = dest_id.as_mut();
3980
3981 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
3982
3983 Ok(())
3984 }
3985 }
3986
3987 impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveRequest<'de> {
3988 type Natural = crate::natural::CapabilityStoreDictionaryRemoveRequest;
3989 }
3990
3991 pub type CapabilityStoreDictionaryRemoveResponse = ::fidl_next::wire::Unit;
3993
3994 #[derive(Clone, Debug)]
3996 #[repr(C)]
3997 pub struct CapabilityStoreDictionaryCopyRequest {
3998 pub id: ::fidl_next::wire::Uint64,
3999
4000 pub dest_id: ::fidl_next::wire::Uint64,
4001 }
4002
4003 static_assertions::const_assert_eq!(
4004 std::mem::size_of::<CapabilityStoreDictionaryCopyRequest>(),
4005 16
4006 );
4007 static_assertions::const_assert_eq!(
4008 std::mem::align_of::<CapabilityStoreDictionaryCopyRequest>(),
4009 8
4010 );
4011
4012 static_assertions::const_assert_eq!(
4013 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, id),
4014 0
4015 );
4016
4017 static_assertions::const_assert_eq!(
4018 std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, dest_id),
4019 8
4020 );
4021
4022 impl ::fidl_next::Constrained for CapabilityStoreDictionaryCopyRequest {
4023 type Constraint = ();
4024
4025 fn validate(
4026 _: ::fidl_next::Slot<'_, Self>,
4027 _: Self::Constraint,
4028 ) -> Result<(), ::fidl_next::ValidationError> {
4029 Ok(())
4030 }
4031 }
4032
4033 unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyRequest {
4034 type Narrowed<'de> = CapabilityStoreDictionaryCopyRequest;
4035
4036 #[inline]
4037 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4038 ::fidl_next::munge! {
4039 let Self {
4040 id,
4041 dest_id,
4042
4043 } = &mut *out_;
4044 }
4045
4046 ::fidl_next::Wire::zero_padding(id);
4047
4048 ::fidl_next::Wire::zero_padding(dest_id);
4049 }
4050 }
4051
4052 unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyRequest
4053 where
4054 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4055 {
4056 fn decode(
4057 slot_: ::fidl_next::Slot<'_, Self>,
4058 decoder_: &mut ___D,
4059 _: (),
4060 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4061 ::fidl_next::munge! {
4062 let Self {
4063 mut id,
4064 mut dest_id,
4065
4066 } = slot_;
4067 }
4068
4069 let _field = id.as_mut();
4070
4071 ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
4072
4073 let _field = dest_id.as_mut();
4074
4075 ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
4076
4077 Ok(())
4078 }
4079 }
4080
4081 impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyRequest {
4082 type Natural = crate::natural::CapabilityStoreDictionaryCopyRequest;
4083 }
4084
4085 pub type CapabilityStoreDictionaryCopyResponse = ::fidl_next::wire::Unit;
4087
4088 pub type CapabilityStoreDictionaryKeysResponse = ::fidl_next::wire::Unit;
4090
4091 pub type CapabilityStoreDictionaryEnumerateResponse = ::fidl_next::wire::Unit;
4093
4094 pub type CapabilityStoreDictionaryDrainResponse = ::fidl_next::wire::Unit;
4096
4097 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4099 #[repr(transparent)]
4100 pub struct RouterError {
4101 pub(crate) value: ::fidl_next::wire::Uint32,
4102 }
4103
4104 impl ::fidl_next::Constrained for RouterError {
4105 type Constraint = ();
4106
4107 fn validate(
4108 _: ::fidl_next::Slot<'_, Self>,
4109 _: Self::Constraint,
4110 ) -> Result<(), ::fidl_next::ValidationError> {
4111 Ok(())
4112 }
4113 }
4114
4115 unsafe impl ::fidl_next::Wire for RouterError {
4116 type Narrowed<'de> = Self;
4117
4118 #[inline]
4119 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4120 }
4122 }
4123
4124 impl RouterError {
4125 pub const NOT_FOUND: RouterError = RouterError { value: ::fidl_next::wire::Uint32(1) };
4126
4127 pub const INVALID_ARGS: RouterError = RouterError { value: ::fidl_next::wire::Uint32(2) };
4128
4129 pub const NOT_SUPPORTED: RouterError = RouterError { value: ::fidl_next::wire::Uint32(3) };
4130
4131 pub const INTERNAL: RouterError = RouterError { value: ::fidl_next::wire::Uint32(4) };
4132 }
4133
4134 unsafe impl<___D> ::fidl_next::Decode<___D> for RouterError
4135 where
4136 ___D: ?Sized,
4137 {
4138 fn decode(
4139 slot: ::fidl_next::Slot<'_, Self>,
4140 _: &mut ___D,
4141 _: (),
4142 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4143 Ok(())
4144 }
4145 }
4146
4147 impl ::core::convert::From<crate::natural::RouterError> for RouterError {
4148 fn from(natural: crate::natural::RouterError) -> Self {
4149 match natural {
4150 crate::natural::RouterError::NotFound => RouterError::NOT_FOUND,
4151
4152 crate::natural::RouterError::InvalidArgs => RouterError::INVALID_ARGS,
4153
4154 crate::natural::RouterError::NotSupported => RouterError::NOT_SUPPORTED,
4155
4156 crate::natural::RouterError::Internal => RouterError::INTERNAL,
4157
4158 crate::natural::RouterError::UnknownOrdinal_(value) => {
4159 RouterError { value: ::fidl_next::wire::Uint32::from(value) }
4160 }
4161 }
4162 }
4163 }
4164
4165 impl ::fidl_next::IntoNatural for RouterError {
4166 type Natural = crate::natural::RouterError;
4167 }
4168
4169 #[derive(Clone, Debug)]
4171 #[repr(C)]
4172 pub struct DictionaryDrainIteratorGetNextRequest {
4173 pub start_id: ::fidl_next::wire::Uint64,
4174
4175 pub limit: ::fidl_next::wire::Uint32,
4176 }
4177
4178 static_assertions::const_assert_eq!(
4179 std::mem::size_of::<DictionaryDrainIteratorGetNextRequest>(),
4180 16
4181 );
4182 static_assertions::const_assert_eq!(
4183 std::mem::align_of::<DictionaryDrainIteratorGetNextRequest>(),
4184 8
4185 );
4186
4187 static_assertions::const_assert_eq!(
4188 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, start_id),
4189 0
4190 );
4191
4192 static_assertions::const_assert_eq!(
4193 std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, limit),
4194 8
4195 );
4196
4197 impl ::fidl_next::Constrained for DictionaryDrainIteratorGetNextRequest {
4198 type Constraint = ();
4199
4200 fn validate(
4201 _: ::fidl_next::Slot<'_, Self>,
4202 _: Self::Constraint,
4203 ) -> Result<(), ::fidl_next::ValidationError> {
4204 Ok(())
4205 }
4206 }
4207
4208 unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextRequest {
4209 type Narrowed<'de> = DictionaryDrainIteratorGetNextRequest;
4210
4211 #[inline]
4212 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4213 ::fidl_next::munge! {
4214 let Self {
4215 start_id,
4216 limit,
4217
4218 } = &mut *out_;
4219 }
4220
4221 ::fidl_next::Wire::zero_padding(start_id);
4222
4223 ::fidl_next::Wire::zero_padding(limit);
4224
4225 unsafe {
4226 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4227 }
4228 }
4229 }
4230
4231 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextRequest
4232 where
4233 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4234 {
4235 fn decode(
4236 slot_: ::fidl_next::Slot<'_, Self>,
4237 decoder_: &mut ___D,
4238 _: (),
4239 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4240 if slot_.as_bytes()[12..16] != [0u8; 4] {
4241 return Err(::fidl_next::DecodeError::InvalidPadding);
4242 }
4243
4244 ::fidl_next::munge! {
4245 let Self {
4246 mut start_id,
4247 mut limit,
4248
4249 } = slot_;
4250 }
4251
4252 let _field = start_id.as_mut();
4253
4254 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
4255
4256 let _field = limit.as_mut();
4257
4258 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
4259
4260 Ok(())
4261 }
4262 }
4263
4264 impl ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextRequest {
4265 type Natural = crate::natural::DictionaryDrainIteratorGetNextRequest;
4266 }
4267
4268 #[derive(Clone, Debug)]
4270 #[repr(C)]
4271 pub struct DictionaryEnumerateIteratorGetNextRequest {
4272 pub start_id: ::fidl_next::wire::Uint64,
4273
4274 pub limit: ::fidl_next::wire::Uint32,
4275 }
4276
4277 static_assertions::const_assert_eq!(
4278 std::mem::size_of::<DictionaryEnumerateIteratorGetNextRequest>(),
4279 16
4280 );
4281 static_assertions::const_assert_eq!(
4282 std::mem::align_of::<DictionaryEnumerateIteratorGetNextRequest>(),
4283 8
4284 );
4285
4286 static_assertions::const_assert_eq!(
4287 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, start_id),
4288 0
4289 );
4290
4291 static_assertions::const_assert_eq!(
4292 std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, limit),
4293 8
4294 );
4295
4296 impl ::fidl_next::Constrained for DictionaryEnumerateIteratorGetNextRequest {
4297 type Constraint = ();
4298
4299 fn validate(
4300 _: ::fidl_next::Slot<'_, Self>,
4301 _: Self::Constraint,
4302 ) -> Result<(), ::fidl_next::ValidationError> {
4303 Ok(())
4304 }
4305 }
4306
4307 unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextRequest {
4308 type Narrowed<'de> = DictionaryEnumerateIteratorGetNextRequest;
4309
4310 #[inline]
4311 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4312 ::fidl_next::munge! {
4313 let Self {
4314 start_id,
4315 limit,
4316
4317 } = &mut *out_;
4318 }
4319
4320 ::fidl_next::Wire::zero_padding(start_id);
4321
4322 ::fidl_next::Wire::zero_padding(limit);
4323
4324 unsafe {
4325 out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
4326 }
4327 }
4328 }
4329
4330 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextRequest
4331 where
4332 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4333 {
4334 fn decode(
4335 slot_: ::fidl_next::Slot<'_, Self>,
4336 decoder_: &mut ___D,
4337 _: (),
4338 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4339 if slot_.as_bytes()[12..16] != [0u8; 4] {
4340 return Err(::fidl_next::DecodeError::InvalidPadding);
4341 }
4342
4343 ::fidl_next::munge! {
4344 let Self {
4345 mut start_id,
4346 mut limit,
4347
4348 } = slot_;
4349 }
4350
4351 let _field = start_id.as_mut();
4352
4353 ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
4354
4355 let _field = limit.as_mut();
4356
4357 ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
4358
4359 Ok(())
4360 }
4361 }
4362
4363 impl ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextRequest {
4364 type Natural = crate::natural::DictionaryEnumerateIteratorGetNextRequest;
4365 }
4366
4367 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4369 #[repr(transparent)]
4370 pub struct DictionaryError {
4371 pub(crate) value: ::fidl_next::wire::Uint32,
4372 }
4373
4374 impl ::fidl_next::Constrained for DictionaryError {
4375 type Constraint = ();
4376
4377 fn validate(
4378 _: ::fidl_next::Slot<'_, Self>,
4379 _: Self::Constraint,
4380 ) -> Result<(), ::fidl_next::ValidationError> {
4381 Ok(())
4382 }
4383 }
4384
4385 unsafe impl ::fidl_next::Wire for DictionaryError {
4386 type Narrowed<'de> = Self;
4387
4388 #[inline]
4389 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4390 }
4392 }
4393
4394 impl DictionaryError {
4395 pub const NOT_FOUND: DictionaryError =
4396 DictionaryError { value: ::fidl_next::wire::Uint32(1) };
4397
4398 pub const ALREADY_EXISTS: DictionaryError =
4399 DictionaryError { value: ::fidl_next::wire::Uint32(2) };
4400
4401 pub const BAD_CAPABILITY: DictionaryError =
4402 DictionaryError { value: ::fidl_next::wire::Uint32(3) };
4403
4404 pub const INVALID_KEY: DictionaryError =
4405 DictionaryError { value: ::fidl_next::wire::Uint32(4) };
4406
4407 pub const NOT_CLONEABLE: DictionaryError =
4408 DictionaryError { value: ::fidl_next::wire::Uint32(5) };
4409 }
4410
4411 unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryError
4412 where
4413 ___D: ?Sized,
4414 {
4415 fn decode(
4416 slot: ::fidl_next::Slot<'_, Self>,
4417 _: &mut ___D,
4418 _: (),
4419 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4420 Ok(())
4421 }
4422 }
4423
4424 impl ::core::convert::From<crate::natural::DictionaryError> for DictionaryError {
4425 fn from(natural: crate::natural::DictionaryError) -> Self {
4426 match natural {
4427 crate::natural::DictionaryError::NotFound => DictionaryError::NOT_FOUND,
4428
4429 crate::natural::DictionaryError::AlreadyExists => DictionaryError::ALREADY_EXISTS,
4430
4431 crate::natural::DictionaryError::BadCapability => DictionaryError::BAD_CAPABILITY,
4432
4433 crate::natural::DictionaryError::InvalidKey => DictionaryError::INVALID_KEY,
4434
4435 crate::natural::DictionaryError::NotCloneable => DictionaryError::NOT_CLONEABLE,
4436
4437 crate::natural::DictionaryError::UnknownOrdinal_(value) => {
4438 DictionaryError { value: ::fidl_next::wire::Uint32::from(value) }
4439 }
4440 }
4441 }
4442 }
4443
4444 impl ::fidl_next::IntoNatural for DictionaryError {
4445 type Natural = crate::natural::DictionaryError;
4446 }
4447
4448 pub type Unavailable = ::fidl_next::wire::Unit;
4450}
4451
4452pub mod wire_optional {
4453
4454 #[repr(transparent)]
4455 pub struct Data<'de> {
4456 pub(crate) raw: ::fidl_next::wire::Union,
4457 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4458 }
4459
4460 impl ::fidl_next::Constrained for Data<'_> {
4461 type Constraint = ();
4462
4463 fn validate(
4464 _: ::fidl_next::Slot<'_, Self>,
4465 _: Self::Constraint,
4466 ) -> Result<(), ::fidl_next::ValidationError> {
4467 Ok(())
4468 }
4469 }
4470
4471 unsafe impl ::fidl_next::Wire for Data<'static> {
4472 type Narrowed<'de> = Data<'de>;
4473
4474 #[inline]
4475 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4476 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4477 ::fidl_next::wire::Union::zero_padding(raw);
4478 }
4479 }
4480
4481 impl<'de> Data<'de> {
4482 pub fn is_some(&self) -> bool {
4483 self.raw.is_some()
4484 }
4485
4486 pub fn is_none(&self) -> bool {
4487 self.raw.is_none()
4488 }
4489
4490 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Data<'de>> {
4491 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4492 }
4493
4494 pub fn into_option(self) -> ::core::option::Option<crate::wire::Data<'de>> {
4495 if self.is_some() {
4496 Some(crate::wire::Data { raw: self.raw, _phantom: ::core::marker::PhantomData })
4497 } else {
4498 None
4499 }
4500 }
4501 }
4502
4503 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Data<'de>
4504 where
4505 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4506 ___D: ::fidl_next::Decoder<'de>,
4507 {
4508 fn decode(
4509 mut slot: ::fidl_next::Slot<'_, Self>,
4510 decoder: &mut ___D,
4511 _: (),
4512 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4513 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4514 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4515 1 => {
4516 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
4517 raw,
4518 decoder,
4519 (8192, ()),
4520 )?
4521 }
4522
4523 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
4524 raw, decoder, 8192,
4525 )?,
4526
4527 3 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Int64>(
4528 raw,
4529 decoder,
4530 (),
4531 )?,
4532
4533 4 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Uint64>(
4534 raw,
4535 decoder,
4536 (),
4537 )?,
4538
4539 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4540 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4541 }
4542
4543 Ok(())
4544 }
4545 }
4546
4547 impl<'de> ::core::fmt::Debug for Data<'de> {
4548 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4549 self.as_ref().fmt(f)
4550 }
4551 }
4552
4553 impl<'de> ::fidl_next::IntoNatural for Data<'de> {
4554 type Natural = ::core::option::Option<crate::natural::Data>;
4555 }
4556}
4557
4558pub mod generic {
4559
4560 pub type Unit = ();
4562
4563 pub struct CapabilityStoreDuplicateRequest<T0, T1> {
4565 pub id: T0,
4566
4567 pub dest_id: T1,
4568 }
4569
4570 unsafe impl<___E, T0, T1>
4571 ::fidl_next::Encode<crate::wire::CapabilityStoreDuplicateRequest, ___E>
4572 for CapabilityStoreDuplicateRequest<T0, T1>
4573 where
4574 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4575 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4576 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4577 {
4578 #[inline]
4579 fn encode(
4580 self,
4581 encoder_: &mut ___E,
4582 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDuplicateRequest>,
4583 _: (),
4584 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4585 ::fidl_next::munge! {
4586 let crate::wire::CapabilityStoreDuplicateRequest {
4587 id,
4588 dest_id,
4589
4590 } = out_;
4591 }
4592
4593 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4594
4595 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4596
4597 Ok(())
4598 }
4599 }
4600
4601 pub type CapabilityStoreDuplicateResponse = ();
4603
4604 pub struct CapabilityStoreDropRequest<T0> {
4606 pub id: T0,
4607 }
4608
4609 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CapabilityStoreDropRequest, ___E>
4610 for CapabilityStoreDropRequest<T0>
4611 where
4612 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4613 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4614 {
4615 #[inline]
4616 fn encode(
4617 self,
4618 encoder_: &mut ___E,
4619 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDropRequest>,
4620 _: (),
4621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4622 ::fidl_next::munge! {
4623 let crate::wire::CapabilityStoreDropRequest {
4624 id,
4625
4626 } = out_;
4627 }
4628
4629 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4630
4631 Ok(())
4632 }
4633 }
4634
4635 pub type CapabilityStoreDropResponse = ();
4637
4638 pub struct CapabilityStoreExportRequest<T0> {
4640 pub id: T0,
4641 }
4642
4643 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::CapabilityStoreExportRequest, ___E>
4644 for CapabilityStoreExportRequest<T0>
4645 where
4646 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4647 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4648 {
4649 #[inline]
4650 fn encode(
4651 self,
4652 encoder_: &mut ___E,
4653 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreExportRequest>,
4654 _: (),
4655 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4656 ::fidl_next::munge! {
4657 let crate::wire::CapabilityStoreExportRequest {
4658 id,
4659
4660 } = out_;
4661 }
4662
4663 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4664
4665 Ok(())
4666 }
4667 }
4668
4669 pub type CapabilityStoreImportResponse = ();
4671
4672 pub type CapabilityStoreConnectorCreateResponse = ();
4674
4675 pub type CapabilityStoreConnectorOpenResponse = ();
4677
4678 pub type CapabilityStoreDirConnectorCreateResponse = ();
4680
4681 pub type CapabilityStoreDirConnectorOpenResponse = ();
4683
4684 pub struct CapabilityStoreDictionaryCreateRequest<T0> {
4686 pub id: T0,
4687 }
4688
4689 unsafe impl<___E, T0>
4690 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCreateRequest, ___E>
4691 for CapabilityStoreDictionaryCreateRequest<T0>
4692 where
4693 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4694 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4695 {
4696 #[inline]
4697 fn encode(
4698 self,
4699 encoder_: &mut ___E,
4700 out_: &mut ::core::mem::MaybeUninit<
4701 crate::wire::CapabilityStoreDictionaryCreateRequest,
4702 >,
4703 _: (),
4704 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4705 ::fidl_next::munge! {
4706 let crate::wire::CapabilityStoreDictionaryCreateRequest {
4707 id,
4708
4709 } = out_;
4710 }
4711
4712 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4713
4714 Ok(())
4715 }
4716 }
4717
4718 pub type CapabilityStoreDictionaryCreateResponse = ();
4720
4721 pub type CapabilityStoreDictionaryLegacyImportResponse = ();
4723
4724 pub type CapabilityStoreDictionaryLegacyExportResponse = ();
4726
4727 pub struct DictionaryItem<T0, T1> {
4729 pub key: T0,
4730
4731 pub value: T1,
4732 }
4733
4734 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>
4735 for DictionaryItem<T0, T1>
4736 where
4737 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4738 ___E: ::fidl_next::Encoder,
4739 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4740 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4741 {
4742 #[inline]
4743 fn encode(
4744 self,
4745 encoder_: &mut ___E,
4746 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryItem<'static>>,
4747 _: (),
4748 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4749 ::fidl_next::munge! {
4750 let crate::wire::DictionaryItem {
4751 key,
4752 value,
4753
4754 } = out_;
4755 }
4756
4757 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
4758
4759 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
4760
4761 Ok(())
4762 }
4763 }
4764
4765 pub struct CapabilityStoreDictionaryInsertRequest<T0, T1> {
4767 pub id: T0,
4768
4769 pub item: T1,
4770 }
4771
4772 unsafe impl<___E, T0, T1>
4773 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryInsertRequest<'static>, ___E>
4774 for CapabilityStoreDictionaryInsertRequest<T0, T1>
4775 where
4776 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4777 ___E: ::fidl_next::Encoder,
4778 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4779 T1: ::fidl_next::Encode<crate::wire::DictionaryItem<'static>, ___E>,
4780 {
4781 #[inline]
4782 fn encode(
4783 self,
4784 encoder_: &mut ___E,
4785 out_: &mut ::core::mem::MaybeUninit<
4786 crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
4787 >,
4788 _: (),
4789 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4790 ::fidl_next::munge! {
4791 let crate::wire::CapabilityStoreDictionaryInsertRequest {
4792 id,
4793 item,
4794
4795 } = out_;
4796 }
4797
4798 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4799
4800 ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
4801
4802 Ok(())
4803 }
4804 }
4805
4806 pub type CapabilityStoreDictionaryInsertResponse = ();
4808
4809 pub struct CapabilityStoreDictionaryGetRequest<T0, T1, T2> {
4811 pub id: T0,
4812
4813 pub key: T1,
4814
4815 pub dest_id: T2,
4816 }
4817
4818 unsafe impl<___E, T0, T1, T2>
4819 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryGetRequest<'static>, ___E>
4820 for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
4821 where
4822 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4823 ___E: ::fidl_next::Encoder,
4824 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4825 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4826 T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4827 {
4828 #[inline]
4829 fn encode(
4830 self,
4831 encoder_: &mut ___E,
4832 out_: &mut ::core::mem::MaybeUninit<
4833 crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
4834 >,
4835 _: (),
4836 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4837 ::fidl_next::munge! {
4838 let crate::wire::CapabilityStoreDictionaryGetRequest {
4839 id,
4840 key,
4841 dest_id,
4842
4843 } = out_;
4844 }
4845
4846 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4847
4848 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
4849
4850 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4851
4852 Ok(())
4853 }
4854 }
4855
4856 pub type CapabilityStoreDictionaryGetResponse = ();
4858
4859 pub struct WrappedCapabilityId<T0> {
4861 pub id: T0,
4862 }
4863
4864 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WrappedCapabilityId, ___E>
4865 for WrappedCapabilityId<T0>
4866 where
4867 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4868 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4869 {
4870 #[inline]
4871 fn encode(
4872 self,
4873 encoder_: &mut ___E,
4874 out_: &mut ::core::mem::MaybeUninit<crate::wire::WrappedCapabilityId>,
4875 _: (),
4876 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4877 ::fidl_next::munge! {
4878 let crate::wire::WrappedCapabilityId {
4879 id,
4880
4881 } = out_;
4882 }
4883
4884 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4885
4886 Ok(())
4887 }
4888 }
4889
4890 pub struct CapabilityStoreDictionaryRemoveRequest<T0, T1, T2> {
4892 pub id: T0,
4893
4894 pub key: T1,
4895
4896 pub dest_id: T2,
4897 }
4898
4899 unsafe impl<___E, T0, T1, T2>
4900 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>, ___E>
4901 for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
4902 where
4903 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4904 ___E: ::fidl_next::Encoder,
4905 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4906 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4907 T2: ::fidl_next::Encode<
4908 ::fidl_next::wire::Box<'static, crate::wire::WrappedCapabilityId>,
4909 ___E,
4910 >,
4911 {
4912 #[inline]
4913 fn encode(
4914 self,
4915 encoder_: &mut ___E,
4916 out_: &mut ::core::mem::MaybeUninit<
4917 crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
4918 >,
4919 _: (),
4920 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4921 ::fidl_next::munge! {
4922 let crate::wire::CapabilityStoreDictionaryRemoveRequest {
4923 id,
4924 key,
4925 dest_id,
4926
4927 } = out_;
4928 }
4929
4930 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4931
4932 ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
4933
4934 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4935
4936 Ok(())
4937 }
4938 }
4939
4940 pub type CapabilityStoreDictionaryRemoveResponse = ();
4942
4943 pub struct CapabilityStoreDictionaryCopyRequest<T0, T1> {
4945 pub id: T0,
4946
4947 pub dest_id: T1,
4948 }
4949
4950 unsafe impl<___E, T0, T1>
4951 ::fidl_next::Encode<crate::wire::CapabilityStoreDictionaryCopyRequest, ___E>
4952 for CapabilityStoreDictionaryCopyRequest<T0, T1>
4953 where
4954 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4955 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4956 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
4957 {
4958 #[inline]
4959 fn encode(
4960 self,
4961 encoder_: &mut ___E,
4962 out_: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityStoreDictionaryCopyRequest>,
4963 _: (),
4964 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4965 ::fidl_next::munge! {
4966 let crate::wire::CapabilityStoreDictionaryCopyRequest {
4967 id,
4968 dest_id,
4969
4970 } = out_;
4971 }
4972
4973 ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4974
4975 ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4976
4977 Ok(())
4978 }
4979 }
4980
4981 pub type CapabilityStoreDictionaryCopyResponse = ();
4983
4984 pub type CapabilityStoreDictionaryKeysResponse = ();
4986
4987 pub type CapabilityStoreDictionaryEnumerateResponse = ();
4989
4990 pub type CapabilityStoreDictionaryDrainResponse = ();
4992
4993 pub struct DictionaryDrainIteratorGetNextRequest<T0, T1> {
4995 pub start_id: T0,
4996
4997 pub limit: T1,
4998 }
4999
5000 unsafe impl<___E, T0, T1>
5001 ::fidl_next::Encode<crate::wire::DictionaryDrainIteratorGetNextRequest, ___E>
5002 for DictionaryDrainIteratorGetNextRequest<T0, T1>
5003 where
5004 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5005 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5006 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5007 {
5008 #[inline]
5009 fn encode(
5010 self,
5011 encoder_: &mut ___E,
5012 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryDrainIteratorGetNextRequest>,
5013 _: (),
5014 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5015 ::fidl_next::munge! {
5016 let crate::wire::DictionaryDrainIteratorGetNextRequest {
5017 start_id,
5018 limit,
5019
5020 } = out_;
5021 }
5022
5023 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
5024
5025 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
5026
5027 Ok(())
5028 }
5029 }
5030
5031 pub struct DictionaryEnumerateIteratorGetNextRequest<T0, T1> {
5033 pub start_id: T0,
5034
5035 pub limit: T1,
5036 }
5037
5038 unsafe impl<___E, T0, T1>
5039 ::fidl_next::Encode<crate::wire::DictionaryEnumerateIteratorGetNextRequest, ___E>
5040 for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
5041 where
5042 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5043 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
5044 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5045 {
5046 #[inline]
5047 fn encode(
5048 self,
5049 encoder_: &mut ___E,
5050 out_: &mut ::core::mem::MaybeUninit<
5051 crate::wire::DictionaryEnumerateIteratorGetNextRequest,
5052 >,
5053 _: (),
5054 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5055 ::fidl_next::munge! {
5056 let crate::wire::DictionaryEnumerateIteratorGetNextRequest {
5057 start_id,
5058 limit,
5059
5060 } = out_;
5061 }
5062
5063 ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
5064
5065 ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
5066
5067 Ok(())
5068 }
5069 }
5070
5071 pub type Unavailable = ();
5073}
5074
5075pub use self::natural::*;
5076
5077#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
5078pub const MAX_NAME_LENGTH: u64 = 255 as u64;
5079
5080#[doc = " Maximum number of bytes in a [Data].\n"]
5081pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
5082
5083#[derive(PartialEq, Debug)]
5085pub struct Dictionary;
5086
5087impl ::fidl_next::Discoverable for Dictionary {
5088 const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
5089}
5090
5091#[cfg(target_os = "fuchsia")]
5092impl ::fidl_next::HasTransport for Dictionary {
5093 type Transport = ::fidl_next::fuchsia::zx::Channel;
5094}
5095
5096pub mod dictionary {
5097 pub mod prelude {
5098 pub use crate::{
5099 Dictionary, DictionaryClientHandler, DictionaryLocalClientHandler,
5100 DictionaryLocalServerHandler, DictionaryServerHandler, dictionary,
5101 };
5102 }
5103
5104 mod ___detail {
5105 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Dictionary
5106 where
5107 ___T: ::fidl_next::Transport,
5108 {
5109 type Client = DictionaryClient<___T>;
5110 type Server = DictionaryServer<___T>;
5111 }
5112
5113 #[repr(transparent)]
5115 pub struct DictionaryClient<___T: ::fidl_next::Transport> {
5116 #[allow(dead_code)]
5117 client: ::fidl_next::protocol::Client<___T>,
5118 }
5119
5120 impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
5121
5122 #[repr(transparent)]
5124 pub struct DictionaryServer<___T: ::fidl_next::Transport> {
5125 server: ::fidl_next::protocol::Server<___T>,
5126 }
5127
5128 impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
5129 }
5130}
5131
5132#[diagnostic::on_unimplemented(
5133 note = "If {Self} implements the non-local DictionaryClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5134)]
5135
5136pub trait DictionaryLocalClientHandler<
5140 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5141 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5142>
5143{
5144 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5145 ::core::future::ready(())
5146 }
5147}
5148
5149impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Dictionary
5150where
5151 ___H: DictionaryLocalClientHandler<___T>,
5152 ___T: ::fidl_next::Transport,
5153{
5154 async fn on_event(
5155 handler: &mut ___H,
5156 ordinal: u64,
5157 flexibility: ::fidl_next::protocol::Flexibility,
5158 body: ::fidl_next::Body<___T>,
5159 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5160 match ordinal {
5161 ordinal => {
5162 handler.on_unknown_interaction(ordinal).await;
5163 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5164 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5165 } else {
5166 Ok(())
5167 }
5168 }
5169 }
5170 }
5171}
5172
5173#[diagnostic::on_unimplemented(
5174 note = "If {Self} implements the non-local DictionaryServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5175)]
5176
5177pub trait DictionaryLocalServerHandler<
5181 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5182 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5183>
5184{
5185 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5186 ::core::future::ready(())
5187 }
5188}
5189
5190impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Dictionary
5191where
5192 ___H: DictionaryLocalServerHandler<___T>,
5193 ___T: ::fidl_next::Transport,
5194{
5195 async fn on_one_way(
5196 handler: &mut ___H,
5197 ordinal: u64,
5198 flexibility: ::fidl_next::protocol::Flexibility,
5199 body: ::fidl_next::Body<___T>,
5200 ) -> ::core::result::Result<
5201 (),
5202 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5203 > {
5204 match ordinal {
5205 ordinal => {
5206 handler.on_unknown_interaction(ordinal).await;
5207 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5208 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5209 } else {
5210 Ok(())
5211 }
5212 }
5213 }
5214 }
5215
5216 async fn on_two_way(
5217 handler: &mut ___H,
5218 ordinal: u64,
5219 flexibility: ::fidl_next::protocol::Flexibility,
5220 body: ::fidl_next::Body<___T>,
5221 responder: ::fidl_next::protocol::Responder<___T>,
5222 ) -> ::core::result::Result<
5223 (),
5224 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5225 > {
5226 match ordinal {
5227 ordinal => {
5228 handler.on_unknown_interaction(ordinal).await;
5229 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5230 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5231 } else {
5232 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5233 ordinal,
5234 flexibility,
5235 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5236 )
5237 .expect("encoding a framework error should never fail")
5238 .await?;
5239 Ok(())
5240 }
5241 }
5242 }
5243 }
5244}
5245
5246pub trait DictionaryClientHandler<
5250 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5251 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5252>
5253{
5254 fn on_unknown_interaction(
5255 &mut self,
5256 ordinal: u64,
5257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5258 ::core::future::ready(())
5259 }
5260}
5261
5262impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
5263where
5264 ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
5265 ___T: ::fidl_next::Transport,
5266{
5267 async fn on_event(
5268 handler: &mut ___H,
5269 ordinal: u64,
5270 flexibility: ::fidl_next::protocol::Flexibility,
5271 body: ::fidl_next::Body<___T>,
5272 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5273 match ordinal {
5274 ordinal => {
5275 handler.on_unknown_interaction(ordinal).await;
5276 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5277 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5278 } else {
5279 Ok(())
5280 }
5281 }
5282 }
5283 }
5284}
5285
5286pub trait DictionaryServerHandler<
5290 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5291 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5292>
5293{
5294 fn on_unknown_interaction(
5295 &mut self,
5296 ordinal: u64,
5297 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5298 ::core::future::ready(())
5299 }
5300}
5301
5302impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
5303where
5304 ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
5305 ___T: ::fidl_next::Transport,
5306{
5307 async fn on_one_way(
5308 handler: &mut ___H,
5309 ordinal: u64,
5310 flexibility: ::fidl_next::protocol::Flexibility,
5311 body: ::fidl_next::Body<___T>,
5312 ) -> ::core::result::Result<
5313 (),
5314 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5315 > {
5316 match ordinal {
5317 ordinal => {
5318 handler.on_unknown_interaction(ordinal).await;
5319 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5320 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5321 } else {
5322 Ok(())
5323 }
5324 }
5325 }
5326 }
5327
5328 async fn on_two_way(
5329 handler: &mut ___H,
5330 ordinal: u64,
5331 flexibility: ::fidl_next::protocol::Flexibility,
5332 body: ::fidl_next::Body<___T>,
5333 responder: ::fidl_next::protocol::Responder<___T>,
5334 ) -> ::core::result::Result<
5335 (),
5336 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5337 > {
5338 match ordinal {
5339 ordinal => {
5340 handler.on_unknown_interaction(ordinal).await;
5341 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5342 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5343 } else {
5344 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5345 ordinal,
5346 flexibility,
5347 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5348 )
5349 .expect("encoding a framework error should never fail")
5350 .await?;
5351 Ok(())
5352 }
5353 }
5354 }
5355 }
5356}
5357
5358impl<___T> DictionaryClientHandler<___T> for ::fidl_next::IgnoreEvents
5359where
5360 ___T: ::fidl_next::Transport,
5361{
5362 async fn on_unknown_interaction(&mut self, _: u64) {}
5363}
5364
5365impl<___H, ___T> DictionaryLocalClientHandler<___T> for ::fidl_next::Local<___H>
5366where
5367 ___H: DictionaryClientHandler<___T>,
5368 ___T: ::fidl_next::Transport,
5369{
5370 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5371 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5372 }
5373}
5374
5375impl<___H, ___T> DictionaryLocalServerHandler<___T> for ::fidl_next::Local<___H>
5376where
5377 ___H: DictionaryServerHandler<___T>,
5378 ___T: ::fidl_next::Transport,
5379{
5380 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5381 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5382 }
5383}
5384
5385#[doc = " Maximum number of items returned by dictionary iterator.\n"]
5386pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;