serde_lite/
serialize.rs

1use std::{
2    borrow::Cow,
3    cell::RefCell,
4    collections::HashMap,
5    convert::TryFrom,
6    rc::Rc,
7    sync::{Arc, Mutex},
8};
9
10use crate::{Error, Intermediate, Map, Number};
11
12/// Serialize trait.
13///
14/// The trait can be implemented by objects the can serialized to the
15/// intermediate representation.
16pub trait Serialize {
17    /// Serialize the object.
18    fn serialize(&self) -> Result<Intermediate, Error>;
19}
20
21impl Serialize for bool {
22    #[inline]
23    fn serialize(&self) -> Result<Intermediate, Error> {
24        Ok(Intermediate::Bool(*self))
25    }
26}
27
28impl Serialize for i64 {
29    #[inline]
30    fn serialize(&self) -> Result<Intermediate, Error> {
31        Ok(Intermediate::Number(Number::SignedInt(*self)))
32    }
33}
34
35impl Serialize for u64 {
36    #[inline]
37    fn serialize(&self) -> Result<Intermediate, Error> {
38        Ok(Intermediate::Number(Number::UnsignedInt(*self)))
39    }
40}
41
42impl Serialize for f32 {
43    #[inline]
44    fn serialize(&self) -> Result<Intermediate, Error> {
45        Ok(Intermediate::Number(Number::Float(*self as _)))
46    }
47}
48
49impl Serialize for f64 {
50    #[inline]
51    fn serialize(&self) -> Result<Intermediate, Error> {
52        Ok(Intermediate::Number(Number::Float(*self)))
53    }
54}
55
56macro_rules! serialize_for_signed_int {
57    ( $x:ty ) => {
58        impl Serialize for $x {
59            #[inline]
60            fn serialize(&self) -> Result<Intermediate, Error> {
61                Ok(Intermediate::Number(Number::SignedInt(i64::from(*self))))
62            }
63        }
64    };
65}
66
67macro_rules! serialize_for_unsigned_int {
68    ( $x:ty ) => {
69        impl Serialize for $x {
70            #[inline]
71            fn serialize(&self) -> Result<Intermediate, Error> {
72                Ok(Intermediate::Number(Number::UnsignedInt(u64::from(*self))))
73            }
74        }
75    };
76}
77
78serialize_for_signed_int!(i8);
79serialize_for_signed_int!(i16);
80serialize_for_signed_int!(i32);
81
82serialize_for_unsigned_int!(u8);
83serialize_for_unsigned_int!(u16);
84serialize_for_unsigned_int!(u32);
85
86impl Serialize for i128 {
87    #[inline]
88    fn serialize(&self) -> Result<Intermediate, Error> {
89        i64::try_from(*self)
90            .map(|v| Intermediate::Number(Number::SignedInt(v)))
91            .map_err(|_| Error::OutOfBounds)
92    }
93}
94
95impl Serialize for u128 {
96    #[inline]
97    fn serialize(&self) -> Result<Intermediate, Error> {
98        u64::try_from(*self)
99            .map(|v| Intermediate::Number(Number::UnsignedInt(v)))
100            .map_err(|_| Error::OutOfBounds)
101    }
102}
103
104impl Serialize for isize {
105    #[inline]
106    fn serialize(&self) -> Result<Intermediate, Error> {
107        i64::try_from(*self)
108            .map(|v| Intermediate::Number(Number::SignedInt(v)))
109            .map_err(|_| Error::OutOfBounds)
110    }
111}
112
113impl Serialize for usize {
114    #[inline]
115    fn serialize(&self) -> Result<Intermediate, Error> {
116        u64::try_from(*self)
117            .map(|v| Intermediate::Number(Number::UnsignedInt(v)))
118            .map_err(|_| Error::OutOfBounds)
119    }
120}
121
122impl Serialize for char {
123    #[inline]
124    fn serialize(&self) -> Result<Intermediate, Error> {
125        Ok(Intermediate::String(Cow::Owned(self.to_string())))
126    }
127}
128
129impl Serialize for String {
130    #[inline]
131    fn serialize(&self) -> Result<Intermediate, Error> {
132        Ok(Intermediate::String(Cow::Owned(self.clone())))
133    }
134}
135
136impl Serialize for &str {
137    #[inline]
138    fn serialize(&self) -> Result<Intermediate, Error> {
139        Ok(Intermediate::String(Cow::Owned(String::from(*self))))
140    }
141}
142
143impl<T> Serialize for Option<T>
144where
145    T: Serialize,
146{
147    #[inline]
148    fn serialize(&self) -> Result<Intermediate, Error> {
149        if let Some(inner) = self.as_ref() {
150            inner.serialize()
151        } else {
152            Ok(Intermediate::None)
153        }
154    }
155}
156
157impl<T> Serialize for &[T]
158where
159    T: Serialize,
160{
161    #[inline]
162    fn serialize(&self) -> Result<Intermediate, Error> {
163        serialize_slice(self)
164    }
165}
166
167impl<T> Serialize for &mut [T]
168where
169    T: Serialize,
170{
171    #[inline]
172    fn serialize(&self) -> Result<Intermediate, Error> {
173        serialize_slice(self)
174    }
175}
176
177impl<T> Serialize for Vec<T>
178where
179    T: Serialize,
180{
181    #[inline]
182    fn serialize(&self) -> Result<Intermediate, Error> {
183        serialize_slice(self)
184    }
185}
186
187impl<T> Serialize for [T; 0] {
188    #[inline]
189    fn serialize(&self) -> Result<Intermediate, Error> {
190        Ok(Intermediate::Array(Vec::new()))
191    }
192}
193
194macro_rules! serialize_array {
195    ( $len:expr ) => {
196        impl<T> Serialize for [T; $len]
197        where
198            T: Serialize,
199        {
200            #[inline]
201            fn serialize(&self) -> Result<Intermediate, Error> {
202                serialize_slice(&self[..])
203            }
204        }
205    };
206}
207
208serialize_array!(1);
209serialize_array!(2);
210serialize_array!(3);
211serialize_array!(4);
212serialize_array!(5);
213serialize_array!(6);
214serialize_array!(7);
215serialize_array!(8);
216serialize_array!(9);
217serialize_array!(10);
218serialize_array!(11);
219serialize_array!(12);
220serialize_array!(13);
221serialize_array!(14);
222serialize_array!(15);
223serialize_array!(16);
224serialize_array!(17);
225serialize_array!(18);
226serialize_array!(19);
227serialize_array!(20);
228serialize_array!(21);
229serialize_array!(22);
230serialize_array!(23);
231serialize_array!(24);
232serialize_array!(25);
233serialize_array!(26);
234serialize_array!(27);
235serialize_array!(28);
236serialize_array!(29);
237serialize_array!(30);
238serialize_array!(31);
239serialize_array!(32);
240
241impl Serialize for () {
242    #[inline]
243    fn serialize(&self) -> Result<Intermediate, Error> {
244        Ok(Intermediate::Array(Vec::new()))
245    }
246}
247
248macro_rules! serialize_tuple {
249    ( $len:expr => ($($n:tt $ty:ident)+) ) => {
250        impl<$($ty),+> Serialize for ($($ty,)+)
251        where
252            $($ty: Serialize,)+
253        {
254            fn serialize(&self) -> Result<Intermediate, Error> {
255                let res = vec![
256                    $(
257                        self.$n.serialize()?,
258                    )+
259                ];
260
261                Ok(Intermediate::Array(res))
262            }
263        }
264    };
265}
266
267serialize_tuple!(1 => (0 T0));
268serialize_tuple!(2 => (0 T0 1 T1));
269serialize_tuple!(3 => (0 T0 1 T1 2 T2));
270serialize_tuple!(4 => (0 T0 1 T1 2 T2 3 T3));
271serialize_tuple!(5 => (0 T0 1 T1 2 T2 3 T3 4 T4));
272serialize_tuple!(6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5));
273serialize_tuple!(7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6));
274serialize_tuple!(8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7));
275serialize_tuple!(9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8));
276serialize_tuple!(10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9));
277serialize_tuple!(11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10));
278serialize_tuple!(12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11));
279serialize_tuple!(13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12));
280serialize_tuple!(14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13));
281serialize_tuple!(15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14));
282serialize_tuple!(16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15));
283
284impl<K, V> Serialize for HashMap<K, V>
285where
286    K: ToString,
287    V: Serialize,
288{
289    fn serialize(&self) -> Result<Intermediate, Error> {
290        let mut res = Map::with_capacity(self.len());
291
292        for (k, v) in self.iter() {
293            res.insert_with_owned_key(k.to_string(), v.serialize()?);
294        }
295
296        Ok(Intermediate::Map(res))
297    }
298}
299
300#[cfg(feature = "preserve-order")]
301impl<K, V> Serialize for indexmap::IndexMap<K, V>
302where
303    K: ToString,
304    V: Serialize,
305{
306    fn serialize(&self) -> Result<Intermediate, Error> {
307        let mut res = Map::with_capacity(self.len());
308
309        for (k, v) in self.iter() {
310            res.insert_with_owned_key(k.to_string(), v.serialize()?);
311        }
312
313        Ok(Intermediate::Map(res))
314    }
315}
316
317impl<T> Serialize for &T
318where
319    T: Serialize + ?Sized,
320{
321    #[inline]
322    fn serialize(&self) -> Result<Intermediate, Error> {
323        <T as Serialize>::serialize(self)
324    }
325}
326
327impl<T> Serialize for &mut T
328where
329    T: Serialize + ?Sized,
330{
331    #[inline]
332    fn serialize(&self) -> Result<Intermediate, Error> {
333        <T as Serialize>::serialize(self)
334    }
335}
336
337macro_rules! serialize_wrapper {
338    ( $x:ident ) => {
339        impl<T> Serialize for $x<T>
340        where
341            T: Serialize + ?Sized,
342        {
343            #[inline]
344            fn serialize(&self) -> Result<Intermediate, Error> {
345                <T as Serialize>::serialize(&*self)
346            }
347        }
348    };
349}
350
351serialize_wrapper!(Box);
352serialize_wrapper!(Rc);
353serialize_wrapper!(Arc);
354
355impl<T> Serialize for Mutex<T>
356where
357    T: Serialize + ?Sized,
358{
359    #[inline]
360    fn serialize(&self) -> Result<Intermediate, Error> {
361        self.lock().unwrap().serialize()
362    }
363}
364
365impl<T> Serialize for RefCell<T>
366where
367    T: Serialize + ?Sized,
368{
369    #[inline]
370    fn serialize(&self) -> Result<Intermediate, Error> {
371        self.borrow().serialize()
372    }
373}
374
375/// Helper function.
376fn serialize_slice<T>(v: &[T]) -> Result<Intermediate, Error>
377where
378    T: Serialize,
379{
380    let mut res = Vec::with_capacity(v.len());
381
382    for elem in v.iter() {
383        res.push(elem.serialize()?);
384    }
385
386    Ok(Intermediate::Array(res))
387}
serde_lite/serialize.rs

serde_lite/
serialize.rs
