fidl_next_common_fuchsia_data/
fidl_next_common_fuchsia_data.rs

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

fidl_next_common_fuchsia_data/
fidl_next_common_fuchsia_data.rs
