fidl_next_fuchsia_data/
fidl_next_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 const MAX_KEY_LENGTH: u32 = 1024;
6
7pub const MAX_NUM_ENTRIES: u32 = 1024;
8
9#[doc = " A key/value pair in a `Dictionary`.\n"]
10#[derive(Clone, Debug)]
11pub struct DictionaryEntry {
12    pub key: String,
13
14    pub value: Option<Box<crate::DictionaryValue>>,
15}
16
17impl ::fidl_next::Encodable for DictionaryEntry {
18    type Encoded = WireDictionaryEntry;
19}
20
21unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEntry
22where
23    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
24
25    ___E: ::fidl_next::Encoder,
26{
27    #[inline]
28    fn encode(
29        &mut self,
30        encoder: &mut ___E,
31        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
32    ) -> Result<(), ::fidl_next::EncodeError> {
33        ::fidl_next::munge! {
34            let Self::Encoded {
35                key,
36                value,
37
38            } = out;
39        }
40
41        ::fidl_next::Encode::encode(&mut self.key, encoder, key)?;
42
43        ::fidl_next::Encode::encode(&mut self.value, encoder, value)?;
44
45        Ok(())
46    }
47}
48
49impl ::fidl_next::EncodableOption for Box<DictionaryEntry> {
50    type EncodedOption = ::fidl_next::WireBox<WireDictionaryEntry>;
51}
52
53unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DictionaryEntry>
54where
55    ___E: ::fidl_next::Encoder + ?Sized,
56    DictionaryEntry: ::fidl_next::Encode<___E>,
57{
58    #[inline]
59    fn encode_option(
60        this: Option<&mut Self>,
61        encoder: &mut ___E,
62        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
63    ) -> Result<(), ::fidl_next::EncodeError> {
64        if let Some(inner) = this {
65            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
66            ::fidl_next::WireBox::encode_present(out);
67        } else {
68            ::fidl_next::WireBox::encode_absent(out);
69        }
70
71        Ok(())
72    }
73}
74
75impl ::fidl_next::TakeFrom<WireDictionaryEntry> for DictionaryEntry {
76    #[inline]
77    fn take_from(from: &WireDictionaryEntry) -> Self {
78        Self {
79            key: ::fidl_next::TakeFrom::take_from(&from.key),
80
81            value: ::fidl_next::TakeFrom::take_from(&from.value),
82        }
83    }
84}
85
86/// The wire type corresponding to [`DictionaryEntry`].
87#[derive(Debug)]
88#[repr(C)]
89pub struct WireDictionaryEntry {
90    pub key: ::fidl_next::WireString,
91
92    pub value: crate::WireOptionalDictionaryValue,
93}
94
95unsafe impl ::fidl_next::ZeroPadding for WireDictionaryEntry {
96    #[inline]
97    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
98}
99
100unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryEntry
101where
102    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
103
104    ___D: ::fidl_next::Decoder,
105{
106    fn decode(
107        slot: ::fidl_next::Slot<'_, Self>,
108        decoder: &mut ___D,
109    ) -> Result<(), ::fidl_next::DecodeError> {
110        ::fidl_next::munge! {
111            let Self {
112                mut key,
113                mut value,
114
115            } = slot;
116        }
117
118        ::fidl_next::Decode::decode(key.as_mut(), decoder)?;
119
120        let key = unsafe { key.deref_unchecked() };
121
122        if key.len() > 1024 {
123            return Err(::fidl_next::DecodeError::VectorTooLong {
124                size: key.len() as u64,
125                limit: 1024,
126            });
127        }
128
129        ::fidl_next::Decode::decode(value.as_mut(), decoder)?;
130
131        Ok(())
132    }
133}
134
135#[doc = " A dictionary is a sequence of key/value pairs.\n Keys must be unique and sorted in lexicographically increasing order.\n"]
136#[derive(Clone, Debug)]
137pub struct Dictionary {
138    pub entries: Option<Vec<crate::DictionaryEntry>>,
139}
140
141impl Dictionary {
142    fn __max_ordinal(&self) -> usize {
143        if self.entries.is_some() {
144            return 1;
145        }
146
147        0
148    }
149}
150
151impl ::fidl_next::Encodable for Dictionary {
152    type Encoded = WireDictionary;
153}
154
155unsafe impl<___E> ::fidl_next::Encode<___E> for Dictionary
156where
157    ___E: ::fidl_next::Encoder + ?Sized,
158{
159    #[inline]
160    fn encode(
161        &mut self,
162        encoder: &mut ___E,
163        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
164    ) -> Result<(), ::fidl_next::EncodeError> {
165        ::fidl_next::munge!(let WireDictionary { table } = out);
166
167        let max_ord = self.__max_ordinal();
168
169        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
170        ::fidl_next::ZeroPadding::zero_padding(&mut out);
171
172        let mut preallocated =
173            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
174
175        for i in 1..=max_ord {
176            match i {
177                1 => {
178                    if let Some(entries) = &mut self.entries {
179                        ::fidl_next::WireEnvelope::encode_value(
180                            entries,
181                            preallocated.encoder,
182                            &mut out,
183                        )?;
184                    } else {
185                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
186                    }
187                }
188
189                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
190            }
191            unsafe {
192                preallocated.write_next(out.assume_init_ref());
193            }
194        }
195
196        ::fidl_next::WireTable::encode_len(table, max_ord);
197
198        Ok(())
199    }
200}
201
202impl ::fidl_next::TakeFrom<WireDictionary> for Dictionary {
203    #[inline]
204    fn take_from(from: &WireDictionary) -> Self {
205        Self { entries: from.entries().map(::fidl_next::TakeFrom::take_from) }
206    }
207}
208
209/// The wire type corresponding to [`Dictionary`].
210#[repr(C)]
211pub struct WireDictionary {
212    table: ::fidl_next::WireTable,
213}
214
215unsafe impl ::fidl_next::ZeroPadding for WireDictionary {
216    #[inline]
217    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
218        ::fidl_next::munge!(let Self { table } = out);
219        ::fidl_next::WireTable::zero_padding(table);
220    }
221}
222
223unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionary
224where
225    ___D: ::fidl_next::Decoder + ?Sized,
226{
227    fn decode(
228        slot: ::fidl_next::Slot<'_, Self>,
229        decoder: &mut ___D,
230    ) -> Result<(), ::fidl_next::DecodeError> {
231        ::fidl_next::munge!(let Self { table } = slot);
232
233        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
234            match ordinal {
235                0 => unsafe { ::core::hint::unreachable_unchecked() },
236
237                1 => {
238                    ::fidl_next::WireEnvelope::decode_as::<
239                        ___D,
240                        ::fidl_next::WireVector<crate::WireDictionaryEntry>,
241                    >(slot.as_mut(), decoder)?;
242
243                    let entries = unsafe {
244                        slot.deref_unchecked()
245                            .deref_unchecked::<::fidl_next::WireVector<crate::WireDictionaryEntry>>(
246                            )
247                    };
248
249                    if entries.len() > 1024 {
250                        return Err(::fidl_next::DecodeError::VectorTooLong {
251                            size: entries.len() as u64,
252                            limit: 1024,
253                        });
254                    }
255
256                    Ok(())
257                }
258
259                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
260            }
261        })
262    }
263}
264
265impl WireDictionary {
266    pub fn entries(&self) -> Option<&::fidl_next::WireVector<crate::WireDictionaryEntry>> {
267        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
268    }
269}
270
271impl ::core::fmt::Debug for WireDictionary {
272    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
273        f.debug_struct("Dictionary").field("entries", &self.entries()).finish()
274    }
275}
276
277pub const MAX_NUM_VALUE_ITEMS: u32 = 1024;
278
279pub const MAX_VALUE_LENGTH: u32 = 32768;
280
281#[doc = " A dictionary\'s value is a string, a list of strings, or a list of objects.\n"]
282#[derive(Clone, Debug)]
283pub enum DictionaryValue {
284    Str(String),
285
286    StrVec(Vec<String>),
287
288    ObjVec(Vec<crate::Dictionary>),
289
290    UnknownOrdinal_(u64),
291}
292
293impl ::fidl_next::Encodable for DictionaryValue {
294    type Encoded = WireDictionaryValue;
295}
296
297unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryValue
298where
299    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
300
301    ___E: ::fidl_next::Encoder,
302{
303    #[inline]
304    fn encode(
305        &mut self,
306        encoder: &mut ___E,
307        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
308    ) -> Result<(), ::fidl_next::EncodeError> {
309        ::fidl_next::munge!(let WireDictionaryValue { raw } = out);
310
311        match self {
312            Self::Str(value) => {
313                ::fidl_next::RawWireUnion::encode_as::<___E, String>(value, 1, encoder, raw)?
314            }
315
316            Self::StrVec(value) => {
317                ::fidl_next::RawWireUnion::encode_as::<___E, Vec<String>>(value, 2, encoder, raw)?
318            }
319
320            Self::ObjVec(value) => ::fidl_next::RawWireUnion::encode_as::<
321                ___E,
322                Vec<crate::Dictionary>,
323            >(value, 3, encoder, raw)?,
324
325            Self::UnknownOrdinal_(ordinal) => {
326                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
327            }
328        }
329
330        Ok(())
331    }
332}
333
334impl ::fidl_next::EncodableOption for Box<DictionaryValue> {
335    type EncodedOption = WireOptionalDictionaryValue;
336}
337
338unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<DictionaryValue>
339where
340    ___E: ?Sized,
341    DictionaryValue: ::fidl_next::Encode<___E>,
342{
343    #[inline]
344    fn encode_option(
345        this: Option<&mut Self>,
346        encoder: &mut ___E,
347        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
348    ) -> Result<(), ::fidl_next::EncodeError> {
349        ::fidl_next::munge!(let WireOptionalDictionaryValue { raw } = &mut *out);
350
351        if let Some(inner) = this {
352            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
353            ::fidl_next::Encode::encode(&mut **inner, encoder, value_out)?;
354        } else {
355            ::fidl_next::RawWireUnion::encode_absent(raw);
356        }
357
358        Ok(())
359    }
360}
361
362impl ::fidl_next::TakeFrom<WireDictionaryValue> for DictionaryValue {
363    #[inline]
364    fn take_from(from: &WireDictionaryValue) -> Self {
365        match from.raw.ordinal() {
366            1 => Self::Str(::fidl_next::TakeFrom::take_from(unsafe {
367                from.raw.get().deref_unchecked::<::fidl_next::WireString>()
368            })),
369
370            2 => Self::StrVec(::fidl_next::TakeFrom::take_from(unsafe {
371                from.raw.get().deref_unchecked::<::fidl_next::WireVector<::fidl_next::WireString>>()
372            })),
373
374            3 => Self::ObjVec(::fidl_next::TakeFrom::take_from(unsafe {
375                from.raw.get().deref_unchecked::<::fidl_next::WireVector<crate::WireDictionary>>()
376            })),
377
378            _ => unsafe { ::core::hint::unreachable_unchecked() },
379        }
380    }
381}
382
383impl ::fidl_next::TakeFrom<WireOptionalDictionaryValue> for Option<Box<DictionaryValue>> {
384    #[inline]
385    fn take_from(from: &WireOptionalDictionaryValue) -> Self {
386        if let Some(inner) = from.as_ref() {
387            Some(::fidl_next::TakeFrom::take_from(inner))
388        } else {
389            None
390        }
391    }
392}
393
394/// The wire type corresponding to [`DictionaryValue`].
395#[repr(transparent)]
396pub struct WireDictionaryValue {
397    raw: ::fidl_next::RawWireUnion,
398}
399
400unsafe impl ::fidl_next::ZeroPadding for WireDictionaryValue {
401    #[inline]
402    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
403        ::fidl_next::munge!(let Self { raw } = out);
404        ::fidl_next::RawWireUnion::zero_padding(raw);
405    }
406}
407
408pub mod dictionary_value {
409    pub enum Ref<'union> {
410        Str(&'union ::fidl_next::WireString),
411
412        StrVec(&'union ::fidl_next::WireVector<::fidl_next::WireString>),
413
414        ObjVec(&'union ::fidl_next::WireVector<crate::WireDictionary>),
415
416        UnknownOrdinal_(u64),
417    }
418}
419
420impl WireDictionaryValue {
421    pub fn as_ref(&self) -> crate::dictionary_value::Ref<'_> {
422        match self.raw.ordinal() {
423            1 => crate::dictionary_value::Ref::Str(unsafe {
424                self.raw.get().deref_unchecked::<::fidl_next::WireString>()
425            }),
426
427            2 => crate::dictionary_value::Ref::StrVec(unsafe {
428                self.raw.get().deref_unchecked::<::fidl_next::WireVector<::fidl_next::WireString>>()
429            }),
430
431            3 => crate::dictionary_value::Ref::ObjVec(unsafe {
432                self.raw.get().deref_unchecked::<::fidl_next::WireVector<crate::WireDictionary>>()
433            }),
434
435            unknown => crate::dictionary_value::Ref::UnknownOrdinal_(unknown),
436        }
437    }
438}
439
440unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryValue
441where
442    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
443
444    ___D: ::fidl_next::Decoder,
445{
446    fn decode(
447        mut slot: ::fidl_next::Slot<'_, Self>,
448        decoder: &mut ___D,
449    ) -> Result<(), ::fidl_next::DecodeError> {
450        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
451        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
452            1 => {
453                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString>(raw, decoder)?
454            }
455
456            2 => ::fidl_next::RawWireUnion::decode_as::<
457                ___D,
458                ::fidl_next::WireVector<::fidl_next::WireString>,
459            >(raw, decoder)?,
460
461            3 => ::fidl_next::RawWireUnion::decode_as::<
462                ___D,
463                ::fidl_next::WireVector<crate::WireDictionary>,
464            >(raw, decoder)?,
465
466            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
467        }
468
469        Ok(())
470    }
471}
472
473impl ::core::fmt::Debug for WireDictionaryValue {
474    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
475        match self.raw.ordinal() {
476            1 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString>().fmt(f) },
477            2 => unsafe {
478                self.raw
479                    .get()
480                    .deref_unchecked::<::fidl_next::WireVector<::fidl_next::WireString>>()
481                    .fmt(f)
482            },
483            3 => unsafe {
484                self.raw
485                    .get()
486                    .deref_unchecked::<::fidl_next::WireVector<crate::WireDictionary>>()
487                    .fmt(f)
488            },
489            _ => unsafe { ::core::hint::unreachable_unchecked() },
490        }
491    }
492}
493
494#[repr(transparent)]
495pub struct WireOptionalDictionaryValue {
496    raw: ::fidl_next::RawWireUnion,
497}
498
499unsafe impl ::fidl_next::ZeroPadding for WireOptionalDictionaryValue {
500    #[inline]
501    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
502        ::fidl_next::munge!(let Self { raw } = out);
503        ::fidl_next::RawWireUnion::zero_padding(raw);
504    }
505}
506
507impl WireOptionalDictionaryValue {
508    pub fn is_some(&self) -> bool {
509        self.raw.is_some()
510    }
511
512    pub fn is_none(&self) -> bool {
513        self.raw.is_none()
514    }
515
516    pub fn as_ref(&self) -> Option<&WireDictionaryValue> {
517        if self.is_some() {
518            Some(unsafe { &*(self as *const Self).cast() })
519        } else {
520            None
521        }
522    }
523}
524
525unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDictionaryValue
526where
527    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
528
529    ___D: ::fidl_next::Decoder,
530{
531    fn decode(
532        mut slot: ::fidl_next::Slot<'_, Self>,
533        decoder: &mut ___D,
534    ) -> Result<(), ::fidl_next::DecodeError> {
535        ::fidl_next::munge!(let Self { mut raw } = slot.as_mut());
536        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
537            1 => {
538                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString>(raw, decoder)?
539            }
540
541            2 => ::fidl_next::RawWireUnion::decode_as::<
542                ___D,
543                ::fidl_next::WireVector<::fidl_next::WireString>,
544            >(raw, decoder)?,
545
546            3 => ::fidl_next::RawWireUnion::decode_as::<
547                ___D,
548                ::fidl_next::WireVector<crate::WireDictionary>,
549            >(raw, decoder)?,
550
551            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
552            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
553        }
554
555        Ok(())
556    }
557}
558
559impl ::core::fmt::Debug for WireOptionalDictionaryValue {
560    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
561        self.as_ref().fmt(f)
562    }
563}
564
565/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
566pub mod compat {
567
568    impl ::fidl_next::TakeFrom<crate::WireDictionaryEntry> for ::fidl_fuchsia_data::DictionaryEntry {
569        #[inline]
570        fn take_from(from: &crate::WireDictionaryEntry) -> Self {
571            Self {
572                key: ::fidl_next::TakeFrom::take_from(&from.key),
573
574                value: ::fidl_next::TakeFrom::take_from(&from.value),
575            }
576        }
577    }
578
579    impl ::fidl_next::TakeFrom<crate::WireDictionary> for ::fidl_fuchsia_data::Dictionary {
580        #[inline]
581        fn take_from(from: &crate::WireDictionary) -> Self {
582            Self {
583                entries: from.entries().map(::fidl_next::TakeFrom::take_from),
584
585                __source_breaking: ::fidl::marker::SourceBreaking,
586            }
587        }
588    }
589
590    impl ::fidl_next::TakeFrom<crate::WireDictionaryValue> for ::fidl_fuchsia_data::DictionaryValue {
591        #[inline]
592        fn take_from(from: &crate::WireDictionaryValue) -> Self {
593            match from.as_ref() {
594                crate::dictionary_value::Ref::Str(value) => {
595                    Self::Str(::fidl_next::TakeFrom::take_from(value))
596                }
597
598                crate::dictionary_value::Ref::StrVec(value) => {
599                    Self::StrVec(::fidl_next::TakeFrom::take_from(value))
600                }
601
602                crate::dictionary_value::Ref::ObjVec(value) => {
603                    Self::ObjVec(::fidl_next::TakeFrom::take_from(value))
604                }
605
606                crate::dictionary_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
607                    Self::__SourceBreaking { unknown_ordinal }
608                }
609            }
610        }
611    }
612
613    impl ::fidl_next::TakeFrom<crate::WireOptionalDictionaryValue>
614        for Option<Box<::fidl_fuchsia_data::DictionaryValue>>
615    {
616        #[inline]
617        fn take_from(from: &crate::WireOptionalDictionaryValue) -> Self {
618            if let Some(inner) = from.as_ref() {
619                Some(::fidl_next::TakeFrom::take_from(inner))
620            } else {
621                None
622            }
623        }
624    }
625}
fidl_next_fuchsia_data/fidl_next_fuchsia_data.rs

fidl_next_fuchsia_data/
fidl_next_fuchsia_data.rs
