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
748 impl<'de> ::core::fmt::Debug for Dictionary<'de> {
749 fn fmt(
750 &self,
751 f: &mut ::core::fmt::Formatter<'_>,
752 ) -> ::core::result::Result<(), ::core::fmt::Error> {
753 f.debug_struct("Dictionary").field("entries", &self.entries()).finish()
754 }
755 }
756
757 impl<'de> ::fidl_next::IntoNatural for Dictionary<'de> {
758 type Natural = crate::natural::Dictionary;
759 }
760
761 #[repr(transparent)]
763 pub struct DictionaryValue<'de> {
764 pub(crate) raw: ::fidl_next::wire::Union,
765 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
766 }
767
768 impl<'de> Drop for DictionaryValue<'de> {
769 fn drop(&mut self) {
770 match self.raw.ordinal() {
771 1 => {
772 let _ = unsafe {
773 self.raw.get().read_unchecked::<::fidl_next::wire::String<'de>>()
774 };
775 }
776
777 2 => {
778 let _ = unsafe {
779 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>>()
780 };
781 }
782
783 3 => {
784 let _ = unsafe {
785 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>>()
786 };
787 }
788
789 _ => (),
790 }
791 }
792 }
793
794 impl ::fidl_next::Constrained for DictionaryValue<'_> {
795 type Constraint = ();
796
797 fn validate(
798 _: ::fidl_next::Slot<'_, Self>,
799 _: Self::Constraint,
800 ) -> Result<(), ::fidl_next::ValidationError> {
801 Ok(())
802 }
803 }
804
805 unsafe impl ::fidl_next::Wire for DictionaryValue<'static> {
806 type Narrowed<'de> = DictionaryValue<'de>;
807
808 #[inline]
809 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
810 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
811 ::fidl_next::wire::Union::zero_padding(raw);
812 }
813 }
814
815 pub mod dictionary_value {
816 pub enum Ref<'de> {
817 Str(&'de ::fidl_next::wire::String<'de>),
818
819 StrVec(&'de ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>),
820
821 ObjVec(&'de ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>),
822
823 UnknownOrdinal_(u64),
824 }
825 }
826
827 impl<'de> DictionaryValue<'de> {
828 pub fn as_ref(&self) -> crate::wire::dictionary_value::Ref<'_> {
829 match self.raw.ordinal() {
830 1 => crate::wire::dictionary_value::Ref::Str(unsafe {
831 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>()
832 }),
833
834 2 => crate::wire::dictionary_value::Ref::StrVec(unsafe {
835 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>>()
836 }),
837
838 3 => crate::wire::dictionary_value::Ref::ObjVec(unsafe {
839 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, crate::wire::Dictionary<'_>>>()
840 }),
841
842 unknown => crate::wire::dictionary_value::Ref::UnknownOrdinal_(unknown),
843 }
844 }
845 }
846
847 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryValue<'de>
848 where
849 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
850 ___D: ::fidl_next::Decoder<'de>,
851 {
852 fn decode(
853 mut slot: ::fidl_next::Slot<'_, Self>,
854 decoder: &mut ___D,
855 _: (),
856 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
857 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
858 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
859 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
860 raw, decoder, 32768,
861 )?,
862
863 2 => ::fidl_next::wire::Union::decode_as::<
864 ___D,
865 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
866 >(raw, decoder, (1024, 32768))?,
867
868 3 => ::fidl_next::wire::Union::decode_as::<
869 ___D,
870 ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>,
871 >(raw, decoder, (1024, ()))?,
872
873 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
874 }
875
876 Ok(())
877 }
878 }
879
880 impl<'de> ::core::fmt::Debug for DictionaryValue<'de> {
881 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
882 match self.raw.ordinal() {
883 1 => unsafe {
884 self.raw.get().deref_unchecked::<::fidl_next::wire::String<'_>>().fmt(f)
885 },
886 2 => unsafe {
887 self.raw.get().deref_unchecked::<
888 ::fidl_next::wire::Vector<'_, ::fidl_next::wire::String<'_>>
889 >().fmt(f)
890 },
891 3 => unsafe {
892 self.raw.get().deref_unchecked::<
893 ::fidl_next::wire::Vector<'_, crate::wire::Dictionary<'_>>
894 >().fmt(f)
895 },
896 _ => unsafe { ::core::hint::unreachable_unchecked() },
897 }
898 }
899 }
900
901 impl<'de> ::fidl_next::IntoNatural for DictionaryValue<'de> {
902 type Natural = crate::natural::DictionaryValue;
903 }
904}
905
906pub mod wire_optional {
907
908 #[repr(transparent)]
909 pub struct DictionaryValue<'de> {
910 pub(crate) raw: ::fidl_next::wire::Union,
911 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
912 }
913
914 impl ::fidl_next::Constrained for DictionaryValue<'_> {
915 type Constraint = ();
916
917 fn validate(
918 _: ::fidl_next::Slot<'_, Self>,
919 _: Self::Constraint,
920 ) -> Result<(), ::fidl_next::ValidationError> {
921 Ok(())
922 }
923 }
924
925 unsafe impl ::fidl_next::Wire for DictionaryValue<'static> {
926 type Narrowed<'de> = DictionaryValue<'de>;
927
928 #[inline]
929 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
930 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
931 ::fidl_next::wire::Union::zero_padding(raw);
932 }
933 }
934
935 impl<'de> DictionaryValue<'de> {
936 pub fn is_some(&self) -> bool {
937 self.raw.is_some()
938 }
939
940 pub fn is_none(&self) -> bool {
941 self.raw.is_none()
942 }
943
944 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DictionaryValue<'de>> {
945 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
946 }
947
948 pub fn into_option(self) -> ::core::option::Option<crate::wire::DictionaryValue<'de>> {
949 if self.is_some() {
950 Some(crate::wire::DictionaryValue {
951 raw: self.raw,
952 _phantom: ::core::marker::PhantomData,
953 })
954 } else {
955 None
956 }
957 }
958 }
959
960 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DictionaryValue<'de>
961 where
962 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
963 ___D: ::fidl_next::Decoder<'de>,
964 {
965 fn decode(
966 mut slot: ::fidl_next::Slot<'_, Self>,
967 decoder: &mut ___D,
968 _: (),
969 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
970 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
971 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
972 1 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::String<'de>>(
973 raw, decoder, 32768,
974 )?,
975
976 2 => ::fidl_next::wire::Union::decode_as::<
977 ___D,
978 ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
979 >(raw, decoder, (1024, 32768))?,
980
981 3 => ::fidl_next::wire::Union::decode_as::<
982 ___D,
983 ::fidl_next::wire::Vector<'de, crate::wire::Dictionary<'de>>,
984 >(raw, decoder, (1024, ()))?,
985
986 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
987 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
988 }
989
990 Ok(())
991 }
992 }
993
994 impl<'de> ::core::fmt::Debug for DictionaryValue<'de> {
995 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
996 self.as_ref().fmt(f)
997 }
998 }
999
1000 impl<'de> ::fidl_next::IntoNatural for DictionaryValue<'de> {
1001 type Natural = ::core::option::Option<crate::natural::DictionaryValue>;
1002 }
1003}
1004
1005pub mod generic {
1006
1007 pub struct DictionaryEntry<T0, T1> {
1009 pub key: T0,
1010
1011 pub value: T1,
1012 }
1013
1014 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DictionaryEntry<'static>, ___E>
1015 for DictionaryEntry<T0, T1>
1016 where
1017 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1018 ___E: ::fidl_next::Encoder,
1019 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
1020 T1: ::fidl_next::Encode<crate::wire_optional::DictionaryValue<'static>, ___E>,
1021 {
1022 #[inline]
1023 fn encode(
1024 self,
1025 encoder_: &mut ___E,
1026 out_: &mut ::core::mem::MaybeUninit<crate::wire::DictionaryEntry<'static>>,
1027 _: (),
1028 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1029 ::fidl_next::munge! {
1030 let crate::wire::DictionaryEntry {
1031 key,
1032 value,
1033
1034 } = out_;
1035 }
1036
1037 ::fidl_next::Encode::encode(self.key, encoder_, key, 1024)?;
1038
1039 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
1040
1041 Ok(())
1042 }
1043 }
1044}
1045
1046pub use self::natural::*;
1047
1048pub const MAX_KEY_LENGTH: u32 = 1024 as u32;
1049
1050pub const MAX_NUM_ENTRIES: u32 = 1024 as u32;
1051
1052pub const MAX_NUM_VALUE_ITEMS: u32 = 1024 as u32;
1053
1054pub const MAX_VALUE_LENGTH: u32 = 32768 as u32;