rune_alloc/serde/
de.rs

1use core::fmt;
2use core::marker::PhantomData;
3
4use serde::de::{Deserialize, Deserializer, Error, SeqAccess, Visitor};
5
6use crate::boxed::Box;
7use crate::sync::Arc;
8use crate::vec::Vec;
9
10mod size_hint {
11    use core::cmp;
12    use core::mem;
13
14    pub fn cautious<Element>(hint: Option<usize>) -> usize {
15        const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
16
17        if mem::size_of::<Element>() == 0 {
18            0
19        } else {
20            cmp::min(
21                hint.unwrap_or(0),
22                MAX_PREALLOC_BYTES / mem::size_of::<Element>(),
23            )
24        }
25    }
26}
27
28mod seed {
29    use serde::de::{Deserialize, DeserializeSeed, Deserializer};
30
31    /// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
32    ///
33    /// Wraps a mutable reference and calls deserialize_in_place on it.
34    pub struct InPlaceSeed<'a, T>(pub &'a mut T)
35    where
36        T: 'a;
37
38    impl<'de, T> DeserializeSeed<'de> for InPlaceSeed<'_, T>
39    where
40        T: Deserialize<'de>,
41    {
42        type Value = ();
43        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
44        where
45            D: Deserializer<'de>,
46        {
47            T::deserialize_in_place(deserializer, self.0)
48        }
49    }
50}
51
52macro_rules! forwarded_impl {
53    (
54        $(#[doc = $doc:tt])*
55        <$($id:ident),*>, $ty:ty, $func:expr
56    ) => {
57        $(#[doc = $doc])*
58        impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
59            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
60            where
61                D: Deserializer<'de>,
62            {
63                let value = Deserialize::deserialize(deserializer)?;
64                $func(value).map_err(D::Error::custom)
65            }
66        }
67    }
68}
69
70#[cfg(any(feature = "std", feature = "alloc"))]
71forwarded_impl!(<T>, Box<T>, Box::try_new);
72#[cfg(any(feature = "std", feature = "alloc"))]
73forwarded_impl!(<T>, Arc<T>, Arc::try_new);
74
75impl<'de, T> Deserialize<'de> for Vec<T>
76where
77    T: Deserialize<'de>,
78{
79    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
80    where
81        D: Deserializer<'de>,
82    {
83        struct VecVisitor<T> {
84            marker: PhantomData<T>,
85        }
86
87        impl<'de, T> Visitor<'de> for VecVisitor<T>
88        where
89            T: Deserialize<'de>,
90        {
91            type Value = Vec<T>;
92
93            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
94                formatter.write_str("a sequence")
95            }
96
97            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
98            where
99                A: SeqAccess<'de>,
100            {
101                let capacity = size_hint::cautious::<T>(seq.size_hint());
102                let mut values = Vec::<T>::try_with_capacity(capacity).map_err(A::Error::custom)?;
103
104                while let Some(value) = seq.next_element()? {
105                    values.try_push(value).map_err(A::Error::custom)?;
106                }
107
108                Ok(values)
109            }
110        }
111
112        let visitor = VecVisitor {
113            marker: PhantomData,
114        };
115
116        deserializer.deserialize_seq(visitor)
117    }
118
119    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
120    where
121        D: Deserializer<'de>,
122    {
123        struct VecInPlaceVisitor<'a, T>(&'a mut Vec<T>)
124        where
125            T: 'a;
126
127        impl<'de, T> Visitor<'de> for VecInPlaceVisitor<'_, T>
128        where
129            T: Deserialize<'de>,
130        {
131            type Value = ();
132
133            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
134                formatter.write_str("a sequence")
135            }
136
137            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
138            where
139                A: SeqAccess<'de>,
140            {
141                let hint = size_hint::cautious::<T>(seq.size_hint());
142
143                if let Some(additional) = hint.checked_sub(self.0.len()) {
144                    self.0.try_reserve(additional).map_err(A::Error::custom)?;
145                }
146
147                for i in 0..self.0.len() {
148                    let next = {
149                        let next_place = seed::InPlaceSeed(&mut self.0[i]);
150                        seq.next_element_seed(next_place)?
151                    };
152
153                    if next.is_none() {
154                        self.0.truncate(i);
155                        return Ok(());
156                    }
157                }
158
159                while let Some(value) = seq.next_element()? {
160                    self.0.try_push(value).map_err(A::Error::custom)?;
161                }
162
163                Ok(())
164            }
165        }
166
167        deserializer.deserialize_seq(VecInPlaceVisitor(place))
168    }
169}
170
171impl<'de, T> Deserialize<'de> for Box<[T]>
172where
173    T: Deserialize<'de>,
174{
175    #[inline]
176    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
177    where
178        D: Deserializer<'de>,
179    {
180        Vec::<T>::deserialize(deserializer)?
181            .try_into_boxed_slice()
182            .map_err(D::Error::custom)
183    }
184}
185
186impl<'de, T> Deserialize<'de> for Arc<[T]>
187where
188    T: Deserialize<'de>,
189{
190    #[inline]
191    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
192    where
193        D: Deserializer<'de>,
194    {
195        let vec = Vec::<T>::deserialize(deserializer)?;
196        Arc::try_from(vec).map_err(D::Error::custom)
197    }
198}
rune_alloc/serde/de.rs

rune_alloc/serde/
de.rs
