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

bump_scope/features/
serde.rs
