fidl_next_codec/wire/vec/
optional.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use core::mem::{needs_drop, MaybeUninit};
6use core::{fmt, slice};
7
8use munge::munge;
9
10use super::raw::RawWireVector;
11use crate::{
12    Decode, DecodeError, Decoder, DecoderExt as _, Encodable, EncodableOption, Encode, EncodeError,
13    EncodeOption, Encoder, EncoderExt as _, Slot, TakeFrom, WirePointer, WireVector, ZeroPadding,
14};
15
16/// An optional FIDL vector
17#[repr(transparent)]
18pub struct WireOptionalVector<T> {
19    raw: RawWireVector<T>,
20}
21
22unsafe impl<T> ZeroPadding for WireOptionalVector<T> {
23    #[inline]
24    fn zero_padding(out: &mut MaybeUninit<Self>) {
25        munge!(let Self { raw } = out);
26        RawWireVector::<T>::zero_padding(raw);
27    }
28}
29
30impl<T> Drop for WireOptionalVector<T> {
31    fn drop(&mut self) {
32        if needs_drop::<T>() && self.is_some() {
33            unsafe {
34                self.raw.as_slice_ptr().drop_in_place();
35            }
36        }
37    }
38}
39
40impl<T> WireOptionalVector<T> {
41    /// Encodes that a vector is present in a slot.
42    pub fn encode_present(out: &mut MaybeUninit<Self>, len: u64) {
43        munge!(let Self { raw } = out);
44        RawWireVector::encode_present(raw, len);
45    }
46
47    /// Encodes that a vector is absent in a slot.
48    pub fn encode_absent(out: &mut MaybeUninit<Self>) {
49        munge!(let Self { raw } = out);
50        RawWireVector::encode_absent(raw);
51    }
52
53    /// Returns whether the vector is present.
54    pub fn is_some(&self) -> bool {
55        !self.raw.as_ptr().is_null()
56    }
57
58    /// Returns whether the vector is absent.
59    pub fn is_none(&self) -> bool {
60        !self.is_some()
61    }
62
63    /// Gets a reference to the vector, if any.
64    pub fn as_ref(&self) -> Option<&WireVector<T>> {
65        if self.is_some() {
66            Some(unsafe { &*(self as *const Self).cast() })
67        } else {
68            None
69        }
70    }
71
72    /// Decodes a wire vector which contains raw data.
73    ///
74    /// # Safety
75    ///
76    /// The elements of the wire vecot rmust not need to be individually decoded, and must always be
77    /// valid.
78    pub unsafe fn decode_raw<D>(
79        mut slot: Slot<'_, Self>,
80        mut decoder: &mut D,
81    ) -> Result<(), DecodeError>
82    where
83        D: Decoder + ?Sized,
84        T: Decode<D>,
85    {
86        munge!(let Self { raw: RawWireVector { len, mut ptr } } = slot.as_mut());
87
88        if WirePointer::is_encoded_present(ptr.as_mut())? {
89            let mut slice = decoder.take_slice_slot::<T>(**len as usize)?;
90            WirePointer::set_decoded(ptr, slice.as_mut_ptr().cast());
91        } else if *len != 0 {
92            return Err(DecodeError::InvalidOptionalSize(**len));
93        }
94
95        Ok(())
96    }
97}
98
99impl<T: fmt::Debug> fmt::Debug for WireOptionalVector<T> {
100    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
101        self.as_ref().fmt(f)
102    }
103}
104
105unsafe impl<D: Decoder + ?Sized, T: Decode<D>> Decode<D> for WireOptionalVector<T> {
106    fn decode(mut slot: Slot<'_, Self>, mut decoder: &mut D) -> Result<(), DecodeError> {
107        munge!(let Self { raw: RawWireVector { len, mut ptr } } = slot.as_mut());
108
109        if WirePointer::is_encoded_present(ptr.as_mut())? {
110            let slice = decoder.decode_next_slice::<T>(**len as usize)?;
111            WirePointer::set_decoded(ptr, slice.into_raw().cast());
112        } else if *len != 0 {
113            return Err(DecodeError::InvalidOptionalSize(**len));
114        }
115
116        Ok(())
117    }
118}
119
120impl<T: Encodable> EncodableOption for Vec<T> {
121    type EncodedOption = WireOptionalVector<T::Encoded>;
122}
123
124unsafe impl<E: Encoder + ?Sized, T: Encode<E>> EncodeOption<E> for Vec<T> {
125    fn encode_option(
126        this: Option<&mut Self>,
127        encoder: &mut E,
128        out: &mut MaybeUninit<Self::EncodedOption>,
129    ) -> Result<(), EncodeError> {
130        if let Some(vec) = this {
131            if T::COPY_OPTIMIZATION.is_enabled() {
132                let bytes = unsafe {
133                    slice::from_raw_parts(vec.as_ptr().cast(), vec.len() * size_of::<T>())
134                };
135                encoder.write(bytes);
136            } else {
137                encoder.encode_next_slice(vec.as_mut_slice())?;
138            }
139            WireOptionalVector::encode_present(out, vec.len() as u64);
140        } else {
141            WireOptionalVector::encode_absent(out);
142        }
143
144        Ok(())
145    }
146}
147
148impl<T: TakeFrom<WT>, WT> TakeFrom<WireOptionalVector<WT>> for Option<Vec<T>> {
149    fn take_from(from: &WireOptionalVector<WT>) -> Self {
150        from.as_ref().map(Vec::take_from)
151    }
152}
fidl_next_codec/wire/vec/optional.rs

fidl_next_codec/wire/vec/
optional.rs
