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