1 // Copyright 2017, Igor Shaula
2 // Licensed under the MIT License <LICENSE or
3 // http://opensource.org/licenses/MIT>. This file
4 // may not be copied, modified, or distributed
5 // except according to those terms.
6 use std::fmt;
7 use std::mem;
8 use super::{Encoder, EncoderError, EncodeResult, ENCODER_SAM};
9 use super::EncoderState::*;
10 use serde::ser::*;
11 
12 impl Error for EncoderError {
custom<T: fmt::Display>(msg: T) -> Self13     fn custom<T: fmt::Display>(msg: T) -> Self {
14         EncoderError::SerializerError(format!("{}", msg))
15     }
16 }
17 
18 
19 impl<'a> Serializer for &'a mut Encoder {
20     type Ok = ();
21     type Error = EncoderError;
22 
23     type SerializeSeq = SeqEncoder;
24     type SerializeTuple = TupleEncoder;
25     type SerializeTupleStruct = TupleStructEncoder;
26     type SerializeTupleVariant = TupleVariantEncoder;
27     type SerializeMap = MapEncoder<'a>;
28     type SerializeStruct = StructEncoder<'a>;
29     type SerializeStructVariant = StructVariantEncoder;
30 
serialize_bool(self, value: bool) -> EncodeResult<Self::Ok>31     fn serialize_bool(self, value: bool) -> EncodeResult<Self::Ok> {
32         self.serialize_u32(value as u32)
33     }
34 
serialize_i8(self, value: i8) -> EncodeResult<Self::Ok>35     fn serialize_i8(self, value: i8) -> EncodeResult<Self::Ok> {
36         self.serialize_i64(value as i64)
37     }
38 
serialize_i16(self, value: i16) -> EncodeResult<Self::Ok>39     fn serialize_i16(self, value: i16) -> EncodeResult<Self::Ok> {
40         self.serialize_i64(value as i64)
41     }
42 
serialize_i32(self, value: i32) -> EncodeResult<Self::Ok>43     fn serialize_i32(self, value: i32) -> EncodeResult<Self::Ok> {
44         self.serialize_i64(value as i64)
45     }
46 
serialize_i64(self, value: i64) -> EncodeResult<Self::Ok>47     fn serialize_i64(self, value: i64) -> EncodeResult<Self::Ok> {
48         let s = value.to_string();
49         emit_value!(self, s)
50     }
51 
serialize_u8(self, value: u8) -> EncodeResult<Self::Ok>52     fn serialize_u8(self, value: u8) -> EncodeResult<Self::Ok> {
53         self.serialize_u32(value as u32)
54     }
55 
serialize_u16(self, value: u16) -> EncodeResult<Self::Ok>56     fn serialize_u16(self, value: u16) -> EncodeResult<Self::Ok> {
57         self.serialize_u32(value as u32)
58     }
59 
serialize_u32(self, value: u32) -> EncodeResult<Self::Ok>60     fn serialize_u32(self, value: u32) -> EncodeResult<Self::Ok> {
61         emit_value!(self, value)
62     }
63 
serialize_u64(self, value: u64) -> EncodeResult<Self::Ok>64     fn serialize_u64(self, value: u64) -> EncodeResult<Self::Ok> {
65         emit_value!(self, value)
66     }
67 
serialize_f32(self, value: f32) -> EncodeResult<Self::Ok>68     fn serialize_f32(self, value: f32) -> EncodeResult<Self::Ok> {
69         let s = value.to_string();
70         emit_value!(self, s)
71     }
72 
serialize_f64(self, value: f64) -> EncodeResult<Self::Ok>73     fn serialize_f64(self, value: f64) -> EncodeResult<Self::Ok> {
74         let s = value.to_string();
75         emit_value!(self, s)
76     }
77 
serialize_char(self, _value: char) -> EncodeResult<Self::Ok>78     fn serialize_char(self, _value: char) -> EncodeResult<Self::Ok> {
79         no_impl!("serialize_char")
80     }
81 
serialize_str(self, value: &str) -> EncodeResult<Self::Ok>82     fn serialize_str(self, value: &str) -> EncodeResult<Self::Ok> {
83         emit_value!(self, value)
84     }
85 
serialize_bytes(self, _value: &[u8]) -> EncodeResult<Self::Ok>86     fn serialize_bytes(self, _value: &[u8]) -> EncodeResult<Self::Ok> {
87         no_impl!("serialize_bytes")
88     }
89 
serialize_none(self) -> EncodeResult<Self::Ok>90     fn serialize_none(self) -> EncodeResult<Self::Ok> {
91         no_impl!("serialize_none")
92     }
93 
serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> EncodeResult<Self::Ok>94     fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> EncodeResult<Self::Ok> {
95         no_impl!("serialize_some")
96     }
97 
serialize_unit(self) -> EncodeResult<Self::Ok>98     fn serialize_unit(self) -> EncodeResult<Self::Ok> {
99         no_impl!("serialize_unit")
100     }
101 
serialize_unit_struct(self, _name: &'static str) -> EncodeResult<Self::Ok>102     fn serialize_unit_struct(self, _name: &'static str) -> EncodeResult<Self::Ok> {
103         no_impl!("serialize_unit_struct")
104     }
105 
serialize_unit_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str) -> EncodeResult<Self::Ok>106     fn serialize_unit_variant(self,
107                               _name: &'static str,
108                               _variant_index: u32,
109                               _variant: &'static str)
110                               -> EncodeResult<Self::Ok> {
111         no_impl!("serialize_unit_variant")
112     }
113 
serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, _value: &T) -> EncodeResult<Self::Ok>114     fn serialize_newtype_struct<T: ?Sized + Serialize>(self,
115                                                        _name: &'static str,
116                                                        _value: &T)
117                                                        -> EncodeResult<Self::Ok> {
118         no_impl!("serialize_newtype_struct")
119     }
120 
serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T) -> EncodeResult<Self::Ok>121     fn serialize_newtype_variant<T: ?Sized + Serialize>(self,
122                                                         _name: &'static str,
123                                                         _variant_index: u32,
124                                                         _variant: &'static str,
125                                                         _value: &T)
126                                                         -> EncodeResult<Self::Ok> {
127         no_impl!("serialize_newtype_variant")
128     }
129 
serialize_seq(self, _len: Option<usize>) -> EncodeResult<Self::SerializeSeq>130     fn serialize_seq(self, _len: Option<usize>) -> EncodeResult<Self::SerializeSeq> {
131         no_impl!("serialize_seq")
132     }
133 
serialize_tuple(self, _len: usize) -> EncodeResult<Self::SerializeTuple>134     fn serialize_tuple(self, _len: usize) -> EncodeResult<Self::SerializeTuple> {
135         no_impl!("serialize_tuple")
136     }
137 
serialize_tuple_struct(self, _name: &'static str, _len: usize) -> EncodeResult<Self::SerializeTupleStruct>138     fn serialize_tuple_struct(self,
139                               _name: &'static str,
140                               _len: usize)
141                               -> EncodeResult<Self::SerializeTupleStruct> {
142         no_impl!("serialize_tuple_struct")
143     }
144 
serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> EncodeResult<Self::SerializeTupleVariant>145     fn serialize_tuple_variant(self,
146                                _name: &'static str,
147                                _variant_index: u32,
148                                _variant: &'static str,
149                                _len: usize)
150                                -> EncodeResult<Self::SerializeTupleVariant> {
151         no_impl!("serialize_tuple_variant")
152     }
153 
serialize_map(self, _len: Option<usize>) -> EncodeResult<Self::SerializeMap>154     fn serialize_map(self, _len: Option<usize>) -> EncodeResult<Self::SerializeMap> {
155         Ok(MapEncoder { _enc: self })
156     }
157 
serialize_struct(self, _name: &'static str, _len: usize) -> EncodeResult<Self::SerializeStruct>158     fn serialize_struct(self,
159                         _name: &'static str,
160                         _len: usize)
161                         -> EncodeResult<Self::SerializeStruct> {
162         match mem::replace(&mut self.state, Start) {
163             Start => {
164                 // root structure
165                 Ok(StructEncoder { enc: self, is_root: true })
166             }
167             NextKey(ref s) => {
168                 // nested structure
169                 match self.keys[self.keys.len() - 1]
170                     .create_subkey_transacted_with_flags(&s, &self.tr, ENCODER_SAM) {
171                     Ok(subkey) => {
172                         self.keys.push(subkey);
173                         Ok(StructEncoder { enc: self, is_root: true })
174                     }
175                     Err(err) => Err(EncoderError::IoError(err)),
176                 }
177             }
178         }
179     }
180 
serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> EncodeResult<Self::SerializeStructVariant>181     fn serialize_struct_variant(self,
182                                 _name: &'static str,
183                                 _variant_index: u32,
184                                 _variant: &'static str,
185                                 _len: usize)
186                                 -> EncodeResult<Self::SerializeStructVariant> {
187         no_impl!("serialize_struct_variant")
188     }
189 }
190 
191 pub struct SeqEncoder {}
192 
193 impl SerializeSeq for SeqEncoder {
194     type Ok = ();
195     type Error = EncoderError;
serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok>196     fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> {
197         no_impl!("SerializeSeq::serialize_element")
198     }
end(self) -> EncodeResult<Self::Ok>199     fn end(self) -> EncodeResult<Self::Ok> {
200         no_impl!("SerializeSeq::end")
201     }
202 }
203 
204 pub struct TupleEncoder {}
205 
206 impl SerializeTuple for TupleEncoder {
207     type Ok = ();
208     type Error = EncoderError;
209 
serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok>210     fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> {
211         no_impl!("SerializeTuple::serialize_element")
212     }
213 
end(self) -> EncodeResult<Self::Ok>214     fn end(self) -> EncodeResult<Self::Ok> {
215         no_impl!("SerializeTuple::end")
216     }
217 }
218 
219 pub struct TupleStructEncoder {}
220 
221 impl SerializeTupleStruct for TupleStructEncoder {
222     type Ok = ();
223     type Error = EncoderError;
224 
serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok>225     fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> {
226         no_impl!("SerializeTupleStruct::serialize_field")
227     }
228 
end(self) -> EncodeResult<Self::Ok>229     fn end(self) -> EncodeResult<Self::Ok> {
230         no_impl!("SerializeTupleStruct::end")
231     }
232 }
233 
234 pub struct TupleVariantEncoder {}
235 
236 impl SerializeTupleVariant for TupleVariantEncoder {
237     type Ok = ();
238     type Error = EncoderError;
239 
serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok>240     fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> {
241         no_impl!("SerializeTupleVariant::serialize_field")
242     }
243 
end(self) -> EncodeResult<Self::Ok>244     fn end(self) -> EncodeResult<Self::Ok> {
245         no_impl!("SerializeTupleVariant::end")
246     }
247 }
248 
249 pub struct MapEncoder<'a> {
250     _enc: &'a mut Encoder,
251 }
252 
253 impl<'a> SerializeMap for MapEncoder<'a> {
254     type Ok = ();
255     type Error = EncoderError;
256 
serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> EncodeResult<Self::Ok>257     fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> EncodeResult<Self::Ok> {
258         no_impl!("SerializeMap::serialize_key")
259     }
260 
serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok>261     fn serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> {
262         no_impl!("SerializeMap::serialize_value")
263     }
264 
end(self) -> EncodeResult<Self::Ok>265     fn end(self) -> EncodeResult<Self::Ok> {
266         no_impl!("SerializeMap::end")
267     }
268 }
269 
270 pub struct StructEncoder<'a> {
271     enc: &'a mut Encoder,
272     is_root: bool
273 }
274 
275 impl<'a> SerializeStruct for StructEncoder<'a> {
276     type Ok = ();
277     type Error = EncoderError;
278 
serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> EncodeResult<Self::Ok>279     fn serialize_field<T: ?Sized + Serialize>(&mut self,
280                                               key: &'static str,
281                                               value: &T)
282                                               -> EncodeResult<Self::Ok> {
283         self.enc.state = NextKey(String::from(key));
284         value.serialize(&mut *self.enc)
285     }
286 
end(self) -> EncodeResult<Self::Ok>287     fn end(self) -> EncodeResult<Self::Ok> {
288         if self.is_root {
289             self.enc.keys.pop();
290         }
291         Ok(())
292     }
293 }
294 
295 pub struct StructVariantEncoder {}
296 
297 impl SerializeStructVariant for StructVariantEncoder {
298     type Ok = ();
299     type Error = EncoderError;
300 
serialize_field<T: ?Sized + Serialize>(&mut self, _key: &'static str, _value: &T) -> EncodeResult<Self::Ok>301     fn serialize_field<T: ?Sized + Serialize>(&mut self,
302                                               _key: &'static str,
303                                               _value: &T)
304                                               -> EncodeResult<Self::Ok> {
305         no_impl!("SerializeStructVariant::serialize_field")
306     }
307 
end(self) -> EncodeResult<Self::Ok>308     fn end(self) -> EncodeResult<Self::Ok> {
309         no_impl!("SerializeStructVariant::end")
310     }
311 }
312 
313