1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 #[doc = " A key/value pair in a `Dictionary`.\n"]
8 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9 pub struct DictionaryEntry {
10 pub key: ::std::string::String,
11
12 pub value: ::core::option::Option<::std::boxed::Box<crate::natural::DictionaryValue>>,
13 }
14
15 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>
16 for DictionaryEntry
17 where
18 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
19 ___E: ::fidl_next::Encoder,
20 {
21 #[inline]
22 fn encode(
23 self,
24 encoder_: &mut ___E,
25 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryEntry<'static>>,
26 _: (),
27 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
28 ::fidl_next::munge! {
29 let crate::wire::DictionaryEntry {
30 key,
31 value,
32
33 } = out_;
34 }
35
36 ::fidl_next::Encode::encode(self.key, encoder_, key, 1024)?;
37
38 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
39 ::fidl_next::Constrained::validate(_field, 1024)?;
40
41 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
42
43 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
44
45 Ok(())
46 }
47 }
48
49 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>
50 for &'a DictionaryEntry
51 where
52 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
53 ___E: ::fidl_next::Encoder,
54 {
55 #[inline]
56 fn encode(
57 self,
58 encoder_: &mut ___E,
59 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryEntry<'static>>,
60 _: (),
61 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
62 ::fidl_next::munge! {
63 let crate::wire::DictionaryEntry {
64 key,
65 value,
66
67 } = out_;
68 }
69
70 ::fidl_next::Encode::encode(&self.key, encoder_, key, 1024)?;
71
72 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
73 ::fidl_next::Constrained::validate(_field, 1024)?;
74
75 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
76
77 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
78
79 Ok(())
80 }
81 }
82
83 unsafe impl<___E>
84 ::fidl_next::EncodeOption<
85 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEntry<'static>>,
86 ___E,
87 > for DictionaryEntry
88 where
89 ___E: ::fidl_next::Encoder + ?Sized,
90 DictionaryEntry: ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>,
91 {
92 #[inline]
93 fn encode_option(
94 this: ::core::option::Option<Self>,
95 encoder: &mut ___E,
96 out: &mut ::core::mem::MaybeUninit<
97 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEntry<'static>>,
98 >,
99 _: (),
100 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
101 if let Some(inner) = this {
102 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
103 ::fidl_next::wire::Box::encode_present(out);
104 } else {
105 ::fidl_next::wire::Box::encode_absent(out);
106 }
107
108 Ok(())
109 }
110 }
111
112 unsafe impl<'a, ___E>
113 ::fidl_next::EncodeOption<
114 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEntry<'static>>,
115 ___E,
116 > for &'a DictionaryEntry
117 where
118 ___E: ::fidl_next::Encoder + ?Sized,
119 &'a DictionaryEntry: ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>,
120 {
121 #[inline]
122 fn encode_option(
123 this: ::core::option::Option<Self>,
124 encoder: &mut ___E,
125 out: &mut ::core::mem::MaybeUninit<
126 ::fidl_next::wire::Box<'static, crate::wire::DictionaryEntry<'static>>,
127 >,
128 _: (),
129 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
130 if let Some(inner) = this {
131 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
132 ::fidl_next::wire::Box::encode_present(out);
133 } else {
134 ::fidl_next::wire::Box::encode_absent(out);
135 }
136
137 Ok(())
138 }
139 }
140
141 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEntry<'de>> for DictionaryEntry {
142 #[inline]
143 fn from_wire(wire: crate::wire::DictionaryEntry<'de>) -> Self {
144 Self {
145 key: ::fidl_next::FromWire::from_wire(wire.key),
146
147 value: ::fidl_next::FromWire::from_wire(wire.value),
148 }
149 }
150 }
151
152 impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryEntry<'de>> for DictionaryEntry {
153 #[inline]
154 fn from_wire_ref(wire: &crate::wire::DictionaryEntry<'de>) -> Self {
155 Self {
156 key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
157
158 value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
159 }
160 }
161 }
162
163 #[doc = " A dictionary is a sequence of key/value pairs.\n Keys must be unique and sorted in lexicographically increasing order.\n"]
164 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
165 pub struct Dictionary {
166 pub entries: ::core::option::Option<::std::vec::Vec<crate::natural::DictionaryEntry>>,
167 }
168
169 impl Dictionary {
170 fn __max_ordinal(&self) -> usize {
171 if self.entries.is_some() {
172 return 1;
173 }
174
175 0
176 }
177 }
178
179 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Dictionary<'static>, ___E> for Dictionary
180 where
181 ___E: ::fidl_next::Encoder + ?Sized,
182 {
183 #[inline]
184 fn encode(
185 mut self,
186 encoder: &mut ___E,
187 out: &mut ::core::mem::MaybeUninit<crate::wire::Dictionary<'static>>,
188 _: (),
189 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
190 ::fidl_next::munge!(let crate::wire::Dictionary { table } = out);
191
192 let max_ord = self.__max_ordinal();
193
194 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
195 ::fidl_next::Wire::zero_padding(&mut out);
196
197 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
198 ::fidl_next::wire::Envelope,
199 >(encoder, max_ord);
200
201 for i in 1..=max_ord {
202 match i {
203 1 => {
204 if let Some(value) = self.entries.take() {
205 ::fidl_next::wire::Envelope::encode_value::<
206 ::fidl_next::wire::Vector<
207 'static,
208 crate::wire::DictionaryEntry<'static>,
209 >,
210 ___E,
211 >(
212 value, preallocated.encoder, &mut out, (1024, ())
213 )?;
214 } else {
215 ::fidl_next::wire::Envelope::encode_zero(&mut out)
216 }
217 }
218
219 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
220 }
221 unsafe {
222 preallocated.write_next(out.assume_init_ref());
223 }
224 }
225
226 ::fidl_next::wire::Table::encode_len(table, max_ord);
227
228 Ok(())
229 }
230 }
231
232 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Dictionary<'static>, ___E> for &'a Dictionary
233 where
234 ___E: ::fidl_next::Encoder + ?Sized,
235 {
236 #[inline]
237 fn encode(
238 self,
239 encoder: &mut ___E,
240 out: &mut ::core::mem::MaybeUninit<crate::wire::Dictionary<'static>>,
241 _: (),
242 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
243 ::fidl_next::munge!(let crate::wire::Dictionary { table } = out);
244
245 let max_ord = self.__max_ordinal();
246
247 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
248 ::fidl_next::Wire::zero_padding(&mut out);
249
250 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
251 ::fidl_next::wire::Envelope,
252 >(encoder, max_ord);
253
254 for i in 1..=max_ord {
255 match i {
256 1 => {
257 if let Some(value) = &self.entries {
258 ::fidl_next::wire::Envelope::encode_value::<
259 ::fidl_next::wire::Vector<
260 'static,
261 crate::wire::DictionaryEntry<'static>,
262 >,
263 ___E,
264 >(
265 value, preallocated.encoder, &mut out, (1024, ())
266 )?;
267 } else {
268 ::fidl_next::wire::Envelope::encode_zero(&mut out)
269 }
270 }
271
272 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
273 }
274 unsafe {
275 preallocated.write_next(out.assume_init_ref());
276 }
277 }
278
279 ::fidl_next::wire::Table::encode_len(table, max_ord);
280
281 Ok(())
282 }
283 }
284
285 impl<'de> ::fidl_next::FromWire<crate::wire::Dictionary<'de>> for Dictionary {
286 #[inline]
287 fn from_wire(wire_: crate::wire::Dictionary<'de>) -> Self {
288 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
289
290 let entries = wire_.table.get(1);
291
292 Self {
293
294
295 entries: entries.map(|envelope| ::fidl_next::FromWire::from_wire(
296 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>>() }
297 )),
298
299 }
300 }
301 }
302
303 impl<'de> ::fidl_next::FromWireRef<crate::wire::Dictionary<'de>> for Dictionary {
304 #[inline]
305 fn from_wire_ref(wire: &crate::wire::Dictionary<'de>) -> Self {
306 Self {
307
308
309 entries: wire.table.get(1)
310 .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
311 unsafe { envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>>() }
312 )),
313
314 }
315 }
316 }
317
318 #[doc = " A dictionary\'s value is a string, a list of strings, or a list of objects.\n"]
319 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
320 pub enum DictionaryValue {
321 Str(::std::string::String),
322
323 StrVec(::std::vec::Vec<::std::string::String>),
324
325 ObjVec(::std::vec::Vec<crate::natural::Dictionary>),
326
327 UnknownOrdinal_(u64),
328 }
329
330 impl DictionaryValue {
331 pub fn is_unknown(&self) -> bool {
332 #[allow(unreachable_patterns)]
333 match self {
334 Self::UnknownOrdinal_(_) => true,
335 _ => false,
336 }
337 }
338 }
339
340 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DictionaryValue<'static>, ___E>
341 for DictionaryValue
342 where
343 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
344 ___E: ::fidl_next::Encoder,
345 {
346 #[inline]
347 fn encode(
348 self,
349 encoder: &mut ___E,
350 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryValue<'static>>,
351 _: (),
352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
353 ::fidl_next::munge!(let crate::wire::DictionaryValue { raw, _phantom: _ } = out);
354
355 match self {
356 Self::Str(value) => ::fidl_next::wire::Union::encode_as::<
357 ___E,
358 ::fidl_next::wire::String<'static>,
359 >(value, 1, encoder, raw, 32768)?,
360
361 Self::StrVec(value) => ::fidl_next::wire::Union::encode_as::<
362 ___E,
363 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
364 >(value, 2, encoder, raw, (1024, 32768))?,
365
366 Self::ObjVec(value) => ::fidl_next::wire::Union::encode_as::<
367 ___E,
368 ::fidl_next::wire::Vector<'static, crate::wire::Dictionary<'static>>,
369 >(value, 3, encoder, raw, (1024, ()))?,
370
371 Self::UnknownOrdinal_(ordinal) => {
372 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
373 }
374 }
375
376 Ok(())
377 }
378 }
379
380 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DictionaryValue<'static>, ___E>
381 for &'a DictionaryValue
382 where
383 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
384 ___E: ::fidl_next::Encoder,
385 {
386 #[inline]
387 fn encode(
388 self,
389 encoder: &mut ___E,
390 out: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryValue<'static>>,
391 _: (),
392 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
393 ::fidl_next::munge!(let crate::wire::DictionaryValue { raw, _phantom: _ } = out);
394
395 match self {
396 DictionaryValue::Str(value) => ::fidl_next::wire::Union::encode_as::<
397 ___E,
398 ::fidl_next::wire::String<'static>,
399 >(value, 1, encoder, raw, 32768)?,
400
401 DictionaryValue::StrVec(value) => {
402 ::fidl_next::wire::Union::encode_as::<
403 ___E,
404 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
405 >(value, 2, encoder, raw, (1024, 32768))?
406 }
407
408 DictionaryValue::ObjVec(value) => {
409 ::fidl_next::wire::Union::encode_as::<
410 ___E,
411 ::fidl_next::wire::Vector<'static, crate::wire::Dictionary<'static>>,
412 >(value, 3, encoder, raw, (1024, ()))?
413 }
414
415 DictionaryValue::UnknownOrdinal_(ordinal) => {
416 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
417 }
418 }
419
420 Ok(())
421 }
422 }
423
424 unsafe impl<___E>
425 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryValue<'static>, ___E>
426 for DictionaryValue
427 where
428 ___E: ?Sized,
429 DictionaryValue: ::fidl_next::Encode<crate::wire::DictionaryValue<'static>, ___E>,
430 {
431 #[inline]
432 fn encode_option(
433 this: ::core::option::Option<Self>,
434 encoder: &mut ___E,
435 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryValue<'static>>,
436 _: (),
437 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
438 ::fidl_next::munge!(let crate::wire_optional::DictionaryValue { raw, _phantom: _ } = &mut *out);
439
440 if let Some(inner) = this {
441 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
442 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
443 } else {
444 ::fidl_next::wire::Union::encode_absent(raw);
445 }
446
447 Ok(())
448 }
449 }
450
451 unsafe impl<'a, ___E>
452 ::fidl_next::EncodeOption<crate::wire_optional::DictionaryValue<'static>, ___E>
453 for &'a DictionaryValue
454 where
455 ___E: ?Sized,
456 &'a DictionaryValue: ::fidl_next::Encode<crate::wire::DictionaryValue<'static>, ___E>,
457 {
458 #[inline]
459 fn encode_option(
460 this: ::core::option::Option<Self>,
461 encoder: &mut ___E,
462 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::DictionaryValue<'static>>,
463 _: (),
464 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
465 ::fidl_next::munge!(let crate::wire_optional::DictionaryValue { raw, _phantom: _ } = &mut *out);
466
467 if let Some(inner) = this {
468 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
469 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
470 } else {
471 ::fidl_next::wire::Union::encode_absent(raw);
472 }
473
474 Ok(())
475 }
476 }
477
478 impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryValue<'de>> for DictionaryValue {
479 #[inline]
480 fn from_wire(wire: crate::wire::DictionaryValue<'de>) -> Self {
481 let wire = ::core::mem::ManuallyDrop::new(wire);
482 match wire.raw.ordinal() {
483 1 => Self::Str(::fidl_next::FromWire::from_wire(unsafe {
484 wire.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
485 })),
486
487 2 => Self::StrVec(::fidl_next::FromWire::from_wire(unsafe {
488 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
489 })),
490
491 3 => Self::ObjVec(::fidl_next::FromWire::from_wire(unsafe {
492 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>>()
493 })),
494
495 ord => return Self::UnknownOrdinal_(ord as u64),
496 }
497 }
498 }
499
500 impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryValue<'de>> for DictionaryValue {
501 #[inline]
502 fn from_wire_ref(wire: &crate::wire::DictionaryValue<'de>) -> Self {
503 match wire.raw.ordinal() {
504 1 => Self::Str(::fidl_next::FromWireRef::from_wire_ref(unsafe {
505 wire.raw.get().deref_unchecked::<::fidl_next::wire::String<'de>>()
506 })),
507
508 2 => Self::StrVec(::fidl_next::FromWireRef::from_wire_ref(unsafe {
509 wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
510 })),
511
512 3 => Self::ObjVec(::fidl_next::FromWireRef::from_wire_ref(unsafe {
513 wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>>()
514 })),
515
516 ord => return Self::UnknownOrdinal_(ord as u64),
517 }
518 }
519 }
520
521 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DictionaryValue<'de>>
522 for DictionaryValue
523 {
524 #[inline]
525 fn from_wire_option(
526 wire: crate::wire_optional::DictionaryValue<'de>,
527 ) -> ::core::option::Option<Self> {
528 if let Some(inner) = wire.into_option() {
529 Some(::fidl_next::FromWire::from_wire(inner))
530 } else {
531 None
532 }
533 }
534 }
535
536 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DictionaryValue<'de>>
537 for Box<DictionaryValue>
538 {
539 #[inline]
540 fn from_wire_option(
541 wire: crate::wire_optional::DictionaryValue<'de>,
542 ) -> ::core::option::Option<Self> {
543 <DictionaryValue as ::fidl_next::FromWireOption<
544 crate::wire_optional::DictionaryValue<'de>,
545 >>::from_wire_option(wire)
546 .map(Box::new)
547 }
548 }
549
550 impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::DictionaryValue<'de>>
551 for Box<DictionaryValue>
552 {
553 #[inline]
554 fn from_wire_option_ref(
555 wire: &crate::wire_optional::DictionaryValue<'de>,
556 ) -> ::core::option::Option<Self> {
557 if let Some(inner) = wire.as_ref() {
558 Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
559 } else {
560 None
561 }
562 }
563 }
564}
565
566pub mod wire {
567
568 #[derive(Debug)]
570 #[repr(C)]
571 pub struct DictionaryEntry<'de> {
572 pub key: ::fidl_next::wire::String<'de>,
573
574 pub value: crate::wire_optional::DictionaryValue<'de>,
575 }
576
577 static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryEntry<'_>>(), 32);
578 static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryEntry<'_>>(), 8);
579
580 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryEntry<'_>, key), 0);
581
582 static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryEntry<'_>, value), 16);
583
584 impl ::fidl_next::Constrained for DictionaryEntry<'_> {
585 type Constraint = ();
586
587 fn validate(
588 _: ::fidl_next::Slot<'_, Self>,
589 _: Self::Constraint,
590 ) -> Result<(), ::fidl_next::ValidationError> {
591 Ok(())
592 }
593 }
594
595 unsafe impl ::fidl_next::Wire for DictionaryEntry<'static> {
596 type Narrowed<'de> = DictionaryEntry<'de>;
597
598 #[inline]
599 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
600 ::fidl_next::munge! {
601 let Self {
602 key,
603 value,
604
605 } = &mut *out_;
606 }
607
608 ::fidl_next::Wire::zero_padding(key);
609
610 ::fidl_next::Wire::zero_padding(value);
611 }
612 }
613
614 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryEntry<'de>
615 where
616 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
617 ___D: ::fidl_next::Decoder<'de>,
618 {
619 fn decode(
620 slot_: ::fidl_next::Slot<'_, Self>,
621 decoder_: &mut ___D,
622 _: (),
623 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
624 ::fidl_next::munge! {
625 let Self {
626 mut key,
627 mut value,
628
629 } = slot_;
630 }
631
632 let _field = key.as_mut();
633 ::fidl_next::Constrained::validate(_field, 1024)?;
634 ::fidl_next::Decode::decode(key.as_mut(), decoder_, 1024)?;
635
636 let key = unsafe { key.deref_unchecked() };
637
638 if key.len() > 1024 {
639 return Err(::fidl_next::DecodeError::VectorTooLong {
640 size: key.len() as u64,
641 limit: 1024,
642 });
643 }
644
645 let _field = value.as_mut();
646
647 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
648
649 Ok(())
650 }
651 }
652
653 impl<'de> ::fidl_next::IntoNatural for DictionaryEntry<'de> {
654 type Natural = crate::natural::DictionaryEntry;
655 }
656
657 #[repr(C)]
659 pub struct Dictionary<'de> {
660 pub(crate) table: ::fidl_next::wire::Table<'de>,
661 }
662
663 impl<'de> Drop for Dictionary<'de> {
664 fn drop(&mut self) {
665 let _ = self.table.get(1)
666 .map(|envelope| unsafe {
667 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>>()
668 });
669 }
670 }
671
672 impl ::fidl_next::Constrained for Dictionary<'_> {
673 type Constraint = ();
674
675 fn validate(
676 _: ::fidl_next::Slot<'_, Self>,
677 _: Self::Constraint,
678 ) -> Result<(), ::fidl_next::ValidationError> {
679 Ok(())
680 }
681 }
682
683 unsafe impl ::fidl_next::Wire for Dictionary<'static> {
684 type Narrowed<'de> = Dictionary<'de>;
685
686 #[inline]
687 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
688 ::fidl_next::munge!(let Self { table } = out);
689 ::fidl_next::wire::Table::zero_padding(table);
690 }
691 }
692
693 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Dictionary<'de>
694 where
695 ___D: ::fidl_next::Decoder<'de> + ?Sized,
696 {
697 fn decode(
698 slot: ::fidl_next::Slot<'_, Self>,
699 decoder: &mut ___D,
700 _: (),
701 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
702 ::fidl_next::munge!(let Self { table } = slot);
703
704 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
705 match ordinal {
706 0 => unsafe { ::core::hint::unreachable_unchecked() },
707
708 1 => {
709 ::fidl_next::wire::Envelope::decode_as::<
710 ___D,
711 ::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>,
712 >(slot.as_mut(), decoder, (1024, ()))?;
713
714 let value = unsafe {
715 slot
716 .deref_unchecked()
717 .deref_unchecked::<
718 ::fidl_next::wire::Vector<'_, crate::wire::DictionaryEntry<'_>>
719 >()
720 };
721
722 if value.len() > 1024 {
723 return Err(::fidl_next::DecodeError::VectorTooLong {
724 size: value.len() as u64,
725 limit: 1024,
726 });
727 }
728
729 Ok(())
730 }
731
732 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
733 }
734 })
735 }
736 }
737
738 impl<'de> Dictionary<'de> {
739 pub fn entries(
740 &self,
741 ) -> ::core::option::Option<
742 &::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>,
743 > {
744 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
745 }
746
747 pub fn take_entries(
748 &mut self,
749 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::DictionaryEntry<'de>>>
750 {
751 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
752 }
753 }
754
755 impl<'de> ::core::fmt::Debug for Dictionary<'de> {
756 fn fmt(
757 &self,
758 f: &mut ::core::fmt::Formatter<'_>,
759 ) -> ::core::result::Result<(), ::core::fmt::Error> {
760 f.debug_struct("Dictionary").field("entries", &self.entries()).finish()
761 }
762 }
763
764 impl<'de> ::fidl_next::IntoNatural for Dictionary<'de> {
765 type Natural = crate::natural::Dictionary;
766 }
767
768 #[repr(transparent)]
770 pub struct DictionaryValue<'de> {
771 pub(crate) raw: ::fidl_next::wire::Union,
772 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
773 }
774
775 impl<'de> Drop for DictionaryValue<'de> {
776 fn drop(&mut self) {
777 match self.raw.ordinal() {
778 1 => {
779 let _ = unsafe {
780 self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
781 };
782 }
783
784 2 => {
785 let _ = unsafe {
786 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
787 };
788 }
789
790 3 => {
791 let _ = unsafe {
792 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>>()
793 };
794 }
795
796 _ => (),
797 }
798 }
799 }
800
801 impl ::fidl_next::Constrained for DictionaryValue<'_> {
802 type Constraint = ();
803
804 fn validate(
805 _: ::fidl_next::Slot<'_, Self>,
806 _: Self::Constraint,
807 ) -> Result<(), ::fidl_next::ValidationError> {
808 Ok(())
809 }
810 }
811
812 unsafe impl ::fidl_next::Wire for DictionaryValue<'static> {
813 type Narrowed<'de> = DictionaryValue<'de>;
814
815 #[inline]
816 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
817 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
818 ::fidl_next::wire::Union::zero_padding(raw);
819 }
820 }
821
822 pub mod dictionary_value {
823 pub enum Ref<'de> {
824 Str(&'de ::fidl_next::wire::String<'de>),
825
826 StrVec(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>),
827
828 ObjVec(&'de ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>),
829
830 UnknownOrdinal_(u64),
831 }
832
833 pub enum Value<'de> {
834 Str(::fidl_next::wire::String<'de>),
835
836 StrVec(::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>),
837
838 ObjVec(::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>),
839
840 UnknownOrdinal_(u64),
841 }
842 }
843
844 impl<'de> DictionaryValue<'de> {
845 pub fn as_ref(&self) -> crate::wire::dictionary_value::Ref<'_> {
846 match self.raw.ordinal() {
847 1 => crate::wire::dictionary_value::Ref::Str(unsafe {
848 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
849 }),
850
851 2 => crate::wire::dictionary_value::Ref::StrVec(unsafe {
852 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>>()
853 }),
854
855 3 => crate::wire::dictionary_value::Ref::ObjVec(unsafe {
856 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, crate::wire::Dictionary<'_>>>()
857 }),
858
859 unknown => crate::wire::dictionary_value::Ref::UnknownOrdinal_(unknown),
860 }
861 }
862
863 pub fn into_inner(self) -> crate::wire::dictionary_value::Value<'de> {
864 let this = ::core::mem::ManuallyDrop::new(self);
865
866 match this.raw.ordinal() {
867 1 => crate::wire::dictionary_value::Value::Str(unsafe {
868 this.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
869 }),
870
871 2 => crate::wire::dictionary_value::Value::StrVec(unsafe {
872 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
873 }),
874
875 3 => crate::wire::dictionary_value::Value::ObjVec(unsafe {
876 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>>()
877 }),
878
879 unknown => crate::wire::dictionary_value::Value::UnknownOrdinal_(unknown),
880 }
881 }
882 }
883
884 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryValue<'de>
885 where
886 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
887 ___D: ::fidl_next::Decoder<'de>,
888 {
889 fn decode(
890 mut slot: ::fidl_next::Slot<'_, Self>,
891 decoder: &mut ___D,
892 _: (),
893 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
894 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
895 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
896 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
897 raw, decoder, 32768,
898 )?,
899
900 2 => ::fidl_next::wire::Union::decode_as::<
901 ___D,
902 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
903 >(raw, decoder, (1024, 32768))?,
904
905 3 => ::fidl_next::wire::Union::decode_as::<
906 ___D,
907 ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>,
908 >(raw, decoder, (1024, ()))?,
909
910 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
911 }
912
913 Ok(())
914 }
915 }
916
917 impl<'de> ::core::fmt::Debug for DictionaryValue<'de> {
918 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
919 match self.raw.ordinal() {
920 1 => unsafe {
921 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
922 },
923 2 => unsafe {
924 self.raw.get().deref_unchecked::<
925 ::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>
926 >().fmt(f)
927 },
928 3 => unsafe {
929 self.raw.get().deref_unchecked::<
930 ::fidl_next::wire::Vector<'_, crate::wire::Dictionary<'_>>
931 >().fmt(f)
932 },
933 _ => unsafe { ::core::hint::unreachable_unchecked() },
934 }
935 }
936 }
937
938 impl<'de> ::fidl_next::IntoNatural for DictionaryValue<'de> {
939 type Natural = crate::natural::DictionaryValue;
940 }
941}
942
943pub mod wire_optional {
944
945 #[repr(transparent)]
946 pub struct DictionaryValue<'de> {
947 pub(crate) raw: ::fidl_next::wire::Union,
948 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
949 }
950
951 impl ::fidl_next::Constrained for DictionaryValue<'_> {
952 type Constraint = ();
953
954 fn validate(
955 _: ::fidl_next::Slot<'_, Self>,
956 _: Self::Constraint,
957 ) -> Result<(), ::fidl_next::ValidationError> {
958 Ok(())
959 }
960 }
961
962 unsafe impl ::fidl_next::Wire for DictionaryValue<'static> {
963 type Narrowed<'de> = DictionaryValue<'de>;
964
965 #[inline]
966 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
967 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
968 ::fidl_next::wire::Union::zero_padding(raw);
969 }
970 }
971
972 impl<'de> DictionaryValue<'de> {
973 pub fn is_some(&self) -> bool {
974 self.raw.is_some()
975 }
976
977 pub fn is_none(&self) -> bool {
978 self.raw.is_none()
979 }
980
981 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DictionaryValue<'de>> {
982 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
983 }
984
985 pub fn into_option(self) -> ::core::option::Option<crate::wire::DictionaryValue<'de>> {
986 if self.is_some() {
987 Some(crate::wire::DictionaryValue {
988 raw: self.raw,
989 _phantom: ::core::marker::PhantomData,
990 })
991 } else {
992 None
993 }
994 }
995 }
996
997 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryValue<'de>
998 where
999 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1000 ___D: ::fidl_next::Decoder<'de>,
1001 {
1002 fn decode(
1003 mut slot: ::fidl_next::Slot<'_, Self>,
1004 decoder: &mut ___D,
1005 _: (),
1006 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1007 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
1008 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
1009 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
1010 raw, decoder, 32768,
1011 )?,
1012
1013 2 => ::fidl_next::wire::Union::decode_as::<
1014 ___D,
1015 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
1016 >(raw, decoder, (1024, 32768))?,
1017
1018 3 => ::fidl_next::wire::Union::decode_as::<
1019 ___D,
1020 ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>,
1021 >(raw, decoder, (1024, ()))?,
1022
1023 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
1024 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
1025 }
1026
1027 Ok(())
1028 }
1029 }
1030
1031 impl<'de> ::core::fmt::Debug for DictionaryValue<'de> {
1032 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1033 self.as_ref().fmt(f)
1034 }
1035 }
1036
1037 impl<'de> ::fidl_next::IntoNatural for DictionaryValue<'de> {
1038 type Natural = ::core::option::Option<crate::natural::DictionaryValue>;
1039 }
1040}
1041
1042pub mod generic {
1043
1044 pub struct DictionaryEntry<T0, T1> {
1046 pub key: T0,
1047
1048 pub value: T1,
1049 }
1050
1051 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>
1052 for DictionaryEntry<T0, T1>
1053 where
1054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1055 ___E: ::fidl_next::Encoder,
1056 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
1057 T1: ::fidl_next::Encode<crate::wire_optional::DictionaryValue<'static>, ___E>,
1058 {
1059 #[inline]
1060 fn encode(
1061 self,
1062 encoder_: &mut ___E,
1063 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryEntry<'static>>,
1064 _: (),
1065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1066 ::fidl_next::munge! {
1067 let crate::wire::DictionaryEntry {
1068 key,
1069 value,
1070
1071 } = out_;
1072 }
1073
1074 ::fidl_next::Encode::encode(self.key, encoder_, key, 1024)?;
1075
1076 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
1077
1078 Ok(())
1079 }
1080 }
1081}
1082
1083pub use self::natural::*;
1084
1085pub const MAX_KEY_LENGTH: u32 = 1024 as u32;
1086
1087pub const MAX_NUM_ENTRIES: u32 = 1024 as u32;
1088
1089pub const MAX_NUM_VALUE_ITEMS: u32 = 1024 as u32;
1090
1091pub const MAX_VALUE_LENGTH: u32 = 32768 as u32;