havok_serde/ser/
impls.rs

Help
1//! Implement [`Serialize`] for each type.
2//!
3//! By calling serializer inside the type, you can easily serialize the type when you use it.
4use crate::lib::*;
5
6use super::{Serialize, Serializer};
7use havok_types::{
8    CString, Matrix3, Matrix4, Pointer, QsTransform, Quaternion, Rotation, StringPtr, Transform,
9    Ulong, Variant, Vector4, f16,
10};
11
12macro_rules! impl_serialize {
13    (*$ty:ty, $fn_name:tt) => {
14        impl Serialize for $ty {
15            #[inline]
16            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
17                serializer.$fn_name(*self)
18            }
19        }
20    };
21    (&$ty:ty, $fn_name:tt) => {
22        impl Serialize for $ty {
23            #[inline]
24            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
25                serializer.$fn_name(&self)
26            }
27        }
28    };
29    ($ty:ty, $fn_name:tt) => {
30        impl Serialize for $ty {
31            #[inline]
32            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
33                serializer.$fn_name(self)
34            }
35        }
36    };
37}
38
39impl_serialize!(*(), serialize_void);
40impl_serialize!(*char, serialize_char);
41impl_serialize!(*bool, serialize_bool);
42impl_serialize!(*i8, serialize_int8);
43impl_serialize!(*i16, serialize_int16);
44impl_serialize!(*i32, serialize_int32);
45impl_serialize!(*i64, serialize_int64);
46impl_serialize!(*u8, serialize_uint8);
47impl_serialize!(*u16, serialize_uint16);
48impl_serialize!(*u32, serialize_uint32);
49impl_serialize!(*u64, serialize_uint64);
50impl_serialize!(*f16, serialize_half);
51impl_serialize!(*f32, serialize_real);
52
53impl_serialize!(Vector4, serialize_vector4);
54impl_serialize!(Quaternion, serialize_quaternion);
55impl_serialize!(Matrix3, serialize_matrix3);
56impl_serialize!(Rotation, serialize_rotation);
57impl_serialize!(QsTransform, serialize_qstransform);
58impl_serialize!(Matrix4, serialize_matrix4);
59impl_serialize!(Transform, serialize_transform);
60
61impl_serialize!(Variant, serialize_variant);
62impl_serialize!(*Pointer, serialize_pointer);
63impl_serialize!(*Ulong, serialize_ulong);
64
65impl Serialize for &str {
66    #[inline]
67    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
68        serializer.serialize_stringptr(&StringPtr::from_str(self))
69    }
70}
71
72impl Serialize for StringPtr<'_> {
73    #[inline]
74    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
75        serializer.serialize_stringptr(self)
76    }
77}
78
79impl Serialize for CString<'_> {
80    #[inline]
81    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
82        serializer.serialize_cstring(self)
83    }
84}
85
86macro_rules! impl_serialize_with_index_array {
87    ($($ty:ty),+ $(,)? => $fn_name:tt) => {
88        $(
89        impl Serialize for Vec<$ty> {
90            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
91                use super::SerializeSeq;
92
93                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
94                for (index, element) in self.iter().enumerate() {
95                    tri!(seq.$fn_name(element, index, self.len()));
96                }
97                seq.end()
98            }
99        }
100
101        impl Serialize for &Vec<$ty> {
102            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
103                use super::SerializeSeq;
104
105                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
106                for (index, element) in self.iter().enumerate() {
107                    tri!(seq.$fn_name(element, index, self.len()));
108                }
109                seq.end()
110            }
111        }
112
113        impl Serialize for &[$ty] {
114            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
115                use super::SerializeSeq;
116
117                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
118                for (index, element) in self.iter().enumerate() {
119                    tri!(seq.$fn_name(element, index, self.len()));
120                }
121                seq.end()
122            }
123        }
124        )*
125    };
126}
127
128impl_serialize_with_index_array!((), bool, char, u8, u16, u32, u64, i8, i16, i32, i64, f16, f32, Pointer, Ulong => serialize_primitive_element);
129
130macro_rules! impl_serialize_vec {
131    ($($ty:ty),+ $(,)? => $fn_name:tt) => {
132        $(
133        impl Serialize for Vec<$ty> {
134            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
135                use super::SerializeSeq;
136
137                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
138                for element in self {
139                    tri!(seq.$fn_name(element));
140                }
141                seq.end()
142            }
143        }
144
145        impl Serialize for &Vec<$ty> {
146            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
147                use super::SerializeSeq;
148
149                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
150                for element in *self {
151                    tri!(seq.$fn_name(element));
152                }
153                seq.end()
154            }
155        }
156
157        impl Serialize for &[$ty] {
158            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
159                use super::SerializeSeq;
160
161                let mut seq = tri!(serializer.serialize_array(Some(self.len())));
162                for element in *self {
163                    tri!(seq.$fn_name(element));
164                }
165                seq.end()
166            }
167        }
168        )*
169    };
170}
171
172impl_serialize_vec!(StringPtr<'_> => serialize_stringptr_element);
173impl_serialize_vec!(CString<'_> => serialize_cstring_element);
174impl_serialize_vec!(Vector4, Quaternion, Matrix3, Rotation, QsTransform, Matrix4, Transform => serialize_math_element);
175
176// impl for Any ClassT.
177impl<T: Serialize + crate::HavokClass> Serialize for Vec<T> {
178    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
179        use super::SerializeSeq;
180
181        let mut seq = tri!(serializer.serialize_array(Some(self.len())));
182        for element in self {
183            tri!(seq.serialize_class_element(element));
184        }
185        seq.end()
186    }
187}
188
189// impl for Any ClassT.
190impl<T: Serialize + crate::HavokClass> Serialize for &Vec<T> {
191    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
192        use super::SerializeSeq;
193
194        let mut seq = tri!(serializer.serialize_array(Some(self.len())));
195        for element in *self {
196            tri!(seq.serialize_class_element(element));
197        }
198        seq.end()
199    }
200}
201
202impl<T: Serialize + crate::HavokClass> Serialize for &[T] {
203    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
204        use super::SerializeSeq;
205
206        let mut seq = tri!(serializer.serialize_array(Some(self.len())));
207        for element in *self {
208            tri!(seq.serialize_class_element(element));
209        }
210        seq.end()
211    }
212}
213
214#[cfg(feature = "indexmap")]
215const _: () = {
216    use indexmap::IndexMap;
217
218    impl<K, V> Serialize for &IndexMap<K, V>
219    where
220        V: Serialize + crate::HavokClass,
221    {
222        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
223            use super::SerializeSeq;
224
225            let mut seq = tri!(serializer.serialize_array(Some(self.len())));
226            for (_index, element) in self.iter() {
227                tri!(seq.serialize_class_element(element));
228            }
229            seq.end()
230        }
231    }
232
233    impl<K, V> Serialize for IndexMap<K, V>
234    where
235        V: Serialize + crate::HavokClass,
236    {
237        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
238            use super::SerializeSeq;
239
240            let mut seq = tri!(serializer.serialize_array(Some(self.len())));
241            for (_index, element) in self.iter() {
242                tri!(seq.serialize_class_element(element));
243            }
244            seq.end()
245        }
246    }
247};
havok_serde/ser/impls.rs

havok_serde/ser/
impls.rs
