data_rw/serde/
serialize_impl.rs

1use crate::serde::error::DataError;
2use crate::Data;
3use serde::ser;
4use serde::Serialize;
5use std::io::Write;
6
7pub struct DataSerializeSeq<'a> {
8    write_mode: u8,
9    write_data: Option<Data>,
10    data: &'a mut Data,
11}
12
13impl<'a> DataSerializeSeq<'a> {
14    #[inline]
15    pub fn new(data: &'a mut Data, len: Option<usize>) -> DataSerializeSeq<'a> {
16        if let Some(len) = len {
17            data.write_fixed(len as u32);
18            DataSerializeSeq {
19                write_mode: 0u8,
20                write_data: None,
21                data,
22            }
23        } else {
24            DataSerializeSeq {
25                write_mode: 1u8,
26                write_data: Some(Data::new()),
27                data,
28            }
29        }
30    }
31}
32
33impl<'a> ser::SerializeSeq for DataSerializeSeq<'a> {
34    type Ok = ();
35    type Error = DataError;
36    #[inline]
37    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
38    where
39        T: Serialize,
40    {
41        if self.write_mode == 0 {
42            value.serialize(&mut *self.data)
43        } else {
44            if let Some(ref mut table) = self.write_data {
45                value.serialize(table)?;
46            }
47            Ok(())
48        }
49    }
50
51    fn end(self) -> Result<Self::Ok, Self::Error> {
52        if self.write_mode == 0 {
53            Ok(())
54        } else {
55            if let Some(ref table) = self.write_data {
56                self.data.write_fixed(table.len() as u32);
57                self.data.write_all(table)?;
58            }
59            Ok(())
60        }
61    }
62}
63
64pub struct DataSerializeTuple<'a> {
65    data: &'a mut Data,
66}
67
68impl<'a> DataSerializeTuple<'a> {
69    #[inline]
70    pub fn new(data: &'a mut Data, len: usize) -> DataSerializeTuple<'_> {
71        data.write_fixed(len as u32);
72        DataSerializeTuple { data }
73    }
74}
75
76impl<'a> ser::SerializeTuple for DataSerializeTuple<'a> {
77    type Ok = ();
78    type Error = DataError;
79    #[inline]
80    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
81    where
82        T: Serialize,
83    {
84        value.serialize(&mut *self.data)
85    }
86    #[inline]
87    fn end(self) -> Result<Self::Ok, Self::Error> {
88        Ok(())
89    }
90}
91
92pub struct DataSerializeTupleStruct<'a> {
93    data: &'a mut Data,
94}
95
96impl<'a> DataSerializeTupleStruct<'a> {
97    #[inline]
98    pub fn new(data: &'a mut Data, len: usize) -> DataSerializeTupleStruct<'a> {
99        data.write_fixed(len as u32);
100        DataSerializeTupleStruct { data }
101    }
102}
103
104impl<'a> ser::SerializeTupleStruct for DataSerializeTupleStruct<'a> {
105    type Ok = ();
106    type Error = DataError;
107    #[inline]
108    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
109    where
110        T: Serialize,
111    {
112        value.serialize(&mut *self.data)
113    }
114    #[inline]
115    fn end(self) -> Result<Self::Ok, Self::Error> {
116        Ok(())
117    }
118}
119
120impl<'a> ser::SerializeStruct for DataSerializeTupleStruct<'a> {
121    type Ok = ();
122    type Error = DataError;
123    #[inline]
124    fn serialize_field<T: ?Sized>(
125        &mut self,
126        key: &'static str,
127        value: &T,
128    ) -> Result<(), Self::Error>
129    where
130        T: Serialize,
131    {
132        self.data.write_fixed(key);
133        value.serialize(&mut *self.data)
134    }
135    #[inline]
136    fn end(self) -> Result<Self::Ok, Self::Error> {
137        Ok(())
138    }
139}
140
141pub struct DataSerializeTupleVariant<'a> {
142    data: &'a mut Data,
143}
144
145impl<'a> DataSerializeTupleVariant<'a> {
146    #[inline]
147    pub fn new(
148        data: &'a mut Data,
149        variant: &'static str,
150        len: usize,
151    ) -> DataSerializeTupleVariant<'a> {
152        data.write_fixed(variant);
153        data.write_fixed(len as u32);
154        DataSerializeTupleVariant { data }
155    }
156}
157
158impl<'a> ser::SerializeTupleVariant for DataSerializeTupleVariant<'a> {
159    type Ok = ();
160    type Error = DataError;
161    #[inline]
162    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
163    where
164        T: Serialize,
165    {
166        value.serialize(&mut *self.data)
167    }
168    #[inline]
169    fn end(self) -> Result<Self::Ok, Self::Error> {
170        Ok(())
171    }
172}
173
174impl<'a> ser::SerializeStructVariant for DataSerializeTupleVariant<'a> {
175    type Ok = ();
176    type Error = DataError;
177    #[inline]
178    fn serialize_field<T: ?Sized>(
179        &mut self,
180        key: &'static str,
181        value: &T,
182    ) -> Result<(), Self::Error>
183    where
184        T: Serialize,
185    {
186        self.data.write_fixed(key);
187        value.serialize(&mut *self.data)
188    }
189    #[inline]
190    fn end(self) -> Result<Self::Ok, Self::Error> {
191        Ok(())
192    }
193}
194
195pub struct DataSerializeMap<'a> {
196    write_mode: u8,
197    write_key: Option<Vec<Data>>,
198    write_value: Option<Vec<Data>>,
199    data: &'a mut Data,
200}
201
202impl<'a> DataSerializeMap<'a> {
203    #[inline]
204    pub fn new(data: &'a mut Data, len: Option<usize>) -> DataSerializeMap<'a> {
205        if let Some(len) = len {
206            data.write_fixed(len as u32);
207            DataSerializeMap {
208                write_mode: 0u8,
209                write_key: None,
210                write_value: None,
211                data,
212            }
213        } else {
214            DataSerializeMap {
215                write_mode: 1u8,
216                write_key: Some(Vec::new()),
217                write_value: Some(Vec::new()),
218                data,
219            }
220        }
221    }
222}
223
224impl<'a> ser::SerializeMap for DataSerializeMap<'a> {
225    type Ok = ();
226    type Error = DataError;
227    #[inline]
228    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
229    where
230        T: Serialize,
231    {
232        if self.write_mode == 0 {
233            key.serialize(&mut *self.data)
234        } else {
235            if let Some(ref mut table) = self.write_key {
236                let mut data = Data::new();
237                key.serialize(&mut data)?;
238                table.push(data);
239            }
240            Ok(())
241        }
242    }
243    #[inline]
244    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
245    where
246        T: Serialize,
247    {
248        if self.write_mode == 0 {
249            value.serialize(&mut *self.data)
250        } else {
251            if let Some(ref mut table) = self.write_value {
252                let mut data = Data::new();
253                value.serialize(&mut data)?;
254                table.push(data);
255            }
256            Ok(())
257        }
258    }
259    #[inline]
260    fn end(mut self) -> Result<Self::Ok, Self::Error> {
261        if self.write_mode == 0 {
262            Ok(())
263        } else {
264            if let Some(ref mut keys) = self.write_key {
265                if let Some(ref mut values) = self.write_value {
266                    assert_eq!(keys.len(), values.len());
267                    self.data.write_fixed(keys.len() as u32);
268                    for i in 0..keys.len() {
269                        let key = keys.get(i).unwrap();
270                        let value = values.get(i).unwrap();
271                        self.data.write_all(key)?;
272                        self.data.write_all(value)?;
273                    }
274                }
275            }
276            Ok(())
277        }
278    }
279}
data_rw/serde/serialize_impl.rs

data_rw/serde/
serialize_impl.rs
