bump_scope/features/
serde.rs

1use core::fmt::{self, Display};
2
3use serde::{
4    Deserialize, Serialize,
5    de::{self, DeserializeSeed, Expected, Visitor},
6};
7
8use crate::{
9    BumpBox, BumpString, BumpVec, FixedBumpString, FixedBumpVec, MutBumpString, MutBumpVec, MutBumpVecRev,
10    alloc::AllocError,
11    traits::{BumpAllocatorTyped, MutBumpAllocatorTyped},
12};
13
14impl<T: Serialize + ?Sized> Serialize for BumpBox<'_, T> {
15    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
16    where
17        S: serde::Serializer,
18    {
19        T::serialize(self, serializer)
20    }
21}
22
23impl<T: Serialize> Serialize for FixedBumpVec<'_, T> {
24    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
25    where
26        S: serde::Serializer,
27    {
28        <[T]>::serialize(self, serializer)
29    }
30}
31
32impl<T: Serialize, A: BumpAllocatorTyped> Serialize for BumpVec<T, A> {
33    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
34    where
35        S: serde::Serializer,
36    {
37        <[T]>::serialize(self, serializer)
38    }
39}
40
41impl<T: Serialize, A> Serialize for MutBumpVec<T, A> {
42    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
43    where
44        S: serde::Serializer,
45    {
46        <[T]>::serialize(self, serializer)
47    }
48}
49
50impl<T: Serialize, A> Serialize for MutBumpVecRev<T, A> {
51    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
52    where
53        S: serde::Serializer,
54    {
55        <[T]>::serialize(self, serializer)
56    }
57}
58
59impl Serialize for FixedBumpString<'_> {
60    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
61    where
62        S: serde::Serializer,
63    {
64        str::serialize(self, serializer)
65    }
66}
67
68impl<A: BumpAllocatorTyped> Serialize for BumpString<A> {
69    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
70    where
71        S: serde::Serializer,
72    {
73        str::serialize(self, serializer)
74    }
75}
76
77impl<A> Serialize for MutBumpString<A> {
78    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
79    where
80        S: serde::Serializer,
81    {
82        str::serialize(self, serializer)
83    }
84}
85
86const AN_ARRAY: &str = "an array";
87const A_STRING: &str = "a string";
88
89struct AllocationFailed;
90
91impl Display for AllocationFailed {
92    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
93        f.write_str("allocation failed")
94    }
95}
96
97fn too_many_elements<E: de::Error>(len: usize, at_most: usize) -> E {
98    E::invalid_length(len, &AtMost(at_most))
99}
100
101fn map_alloc_error<E: de::Error>(result: Result<(), AllocError>) -> Result<(), E> {
102    match result {
103        Ok(()) => Ok(()),
104        Err(AllocError) => Err(E::custom(&AllocationFailed)),
105    }
106}
107
108struct AtMost(usize);
109
110impl Expected for AtMost {
111    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
112        write!(formatter, "at most {}", self.0)
113    }
114}
115
116impl<'de, T: Deserialize<'de>> DeserializeSeed<'de> for &'_ mut FixedBumpVec<'_, T> {
117    type Value = ();
118
119    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
120    where
121        D: serde::Deserializer<'de>,
122    {
123        deserializer.deserialize_seq(self)
124    }
125}
126
127impl<'de, T: Deserialize<'de>> Visitor<'de> for &'_ mut FixedBumpVec<'_, T> {
128    type Value = ();
129
130    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
131        formatter.write_str(AN_ARRAY)
132    }
133
134    fn visit_seq<Seq>(self, mut seq: Seq) -> Result<Self::Value, Seq::Error>
135    where
136        Seq: serde::de::SeqAccess<'de>,
137    {
138        let remaining = self.capacity() - self.len();
139
140        if let Some(size_hint) = seq.size_hint() {
141            if size_hint > remaining {
142                return Err(too_many_elements(size_hint, remaining));
143            }
144        }
145
146        while let Some(elem) = seq.next_element()? {
147            if self.try_push(elem).is_err() {
148                return Err(too_many_elements(self.len().saturating_add(1), remaining));
149            }
150        }
151
152        Ok(())
153    }
154}
155
156impl<'de, T: Deserialize<'de>, A: BumpAllocatorTyped> DeserializeSeed<'de> for &'_ mut BumpVec<T, A> {
157    type Value = ();
158
159    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
160    where
161        D: serde::Deserializer<'de>,
162    {
163        deserializer.deserialize_seq(self)
164    }
165}
166
167impl<'de, T: Deserialize<'de>, A: BumpAllocatorTyped> Visitor<'de> for &'_ mut BumpVec<T, A> {
168    type Value = ();
169
170    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
171        formatter.write_str(AN_ARRAY)
172    }
173
174    fn visit_seq<Seq>(self, mut seq: Seq) -> Result<Self::Value, Seq::Error>
175    where
176        Seq: serde::de::SeqAccess<'de>,
177    {
178        if let Some(size_hint) = seq.size_hint() {
179            map_alloc_error(self.try_reserve(size_hint))?;
180        }
181
182        while let Some(elem) = seq.next_element()? {
183            map_alloc_error(self.try_push(elem))?;
184        }
185
186        Ok(())
187    }
188}
189
190impl<'de, T: Deserialize<'de>, A: MutBumpAllocatorTyped> DeserializeSeed<'de> for &'_ mut MutBumpVec<T, A> {
191    type Value = ();
192
193    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
194    where
195        D: serde::Deserializer<'de>,
196    {
197        deserializer.deserialize_seq(self)
198    }
199}
200
201impl<'de, T: Deserialize<'de>, A: MutBumpAllocatorTyped> Visitor<'de> for &'_ mut MutBumpVec<T, A> {
202    type Value = ();
203
204    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
205        formatter.write_str(AN_ARRAY)
206    }
207
208    fn visit_seq<Seq>(self, mut seq: Seq) -> Result<Self::Value, Seq::Error>
209    where
210        Seq: serde::de::SeqAccess<'de>,
211    {
212        if let Some(size_hint) = seq.size_hint() {
213            map_alloc_error(self.try_reserve(size_hint))?;
214        }
215
216        while let Some(elem) = seq.next_element()? {
217            map_alloc_error(self.try_push(elem))?;
218        }
219
220        Ok(())
221    }
222}
223
224impl<'de, T: Deserialize<'de>, A: MutBumpAllocatorTyped> DeserializeSeed<'de> for &mut MutBumpVecRev<T, A> {
225    type Value = ();
226
227    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
228    where
229        D: serde::Deserializer<'de>,
230    {
231        deserializer.deserialize_seq(self)
232    }
233}
234
235impl<'de, T: Deserialize<'de>, A: MutBumpAllocatorTyped> Visitor<'de> for &mut MutBumpVecRev<T, A> {
236    type Value = ();
237
238    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
239        formatter.write_str(AN_ARRAY)
240    }
241
242    fn visit_seq<Seq>(self, mut seq: Seq) -> Result<Self::Value, Seq::Error>
243    where
244        Seq: serde::de::SeqAccess<'de>,
245    {
246        if let Some(size_hint) = seq.size_hint() {
247            map_alloc_error(self.try_reserve(size_hint))?;
248        }
249
250        while let Some(elem) = seq.next_element()? {
251            map_alloc_error(self.try_push(elem))?;
252        }
253
254        Ok(())
255    }
256}
257
258impl<'de> DeserializeSeed<'de> for &'_ mut FixedBumpString<'_> {
259    type Value = ();
260
261    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
262    where
263        D: serde::Deserializer<'de>,
264    {
265        deserializer.deserialize_str(self)
266    }
267}
268
269impl Visitor<'_> for &'_ mut FixedBumpString<'_> {
270    type Value = ();
271
272    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
273        formatter.write_str(A_STRING)
274    }
275
276    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
277    where
278        E: de::Error,
279    {
280        map_alloc_error(self.try_push_str(v))
281    }
282}
283
284impl<'de, A: BumpAllocatorTyped> DeserializeSeed<'de> for &'_ mut BumpString<A> {
285    type Value = ();
286
287    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
288    where
289        D: serde::Deserializer<'de>,
290    {
291        deserializer.deserialize_str(self)
292    }
293}
294
295impl<A: BumpAllocatorTyped> Visitor<'_> for &'_ mut BumpString<A> {
296    type Value = ();
297
298    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
299        formatter.write_str(A_STRING)
300    }
301
302    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
303    where
304        E: de::Error,
305    {
306        map_alloc_error(self.try_push_str(v))
307    }
308}
309
310impl<'de, A: MutBumpAllocatorTyped> DeserializeSeed<'de> for &'_ mut MutBumpString<A> {
311    type Value = ();
312
313    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
314    where
315        D: serde::Deserializer<'de>,
316    {
317        deserializer.deserialize_str(self)
318    }
319}
320
321impl<A: MutBumpAllocatorTyped> Visitor<'_> for &mut MutBumpString<A> {
322    type Value = ();
323
324    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
325        formatter.write_str(A_STRING)
326    }
327
328    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
329    where
330        E: de::Error,
331    {
332        map_alloc_error(self.try_push_str(v))
333    }
334}
bump_scope/features/serde.rs

bump_scope/features/
serde.rs
