1use std::convert::TryInto;23use linked_hash_map::LinkedHashMap;4use serde::{5 Serializer,6 ser::{7 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,8 SerializeTupleStruct, SerializeTupleVariant,9 },10};1112use crate::{Error, Value};1314impl ser::Error for Error {15 fn custom<T>(msg: T) -> Self16 where17 T: std::fmt::Display,18 {19 Self::Custom(format!("{}", msg))20 }21}2223pub struct MySerializeSeq(Vec<Value>);2425impl SerializeSeq for MySerializeSeq {26 type Ok = Value;2728 type Error = Error;2930 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>31 where32 T: serde::Serialize,33 T: ?Sized,34 {35 self.0.push(value.serialize(MySerialize)?);36 Ok(())37 }3839 fn end(self) -> Result<Self::Ok, Self::Error> {40 Ok(Value::Array(self.0))41 }42}43impl SerializeTuple for MySerializeSeq {44 type Ok = Value;4546 type Error = Error;4748 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>49 where50 T: serde::Serialize,51 T: ?Sized,52 {53 self.0.push(value.serialize(MySerialize)?);54 Ok(())55 }5657 fn end(self) -> Result<Self::Ok, Self::Error> {58 Ok(Value::Array(self.0))59 }60}61impl SerializeTupleStruct for MySerializeSeq {62 type Ok = Value;6364 type Error = Error;6566 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>67 where68 T: serde::Serialize,69 T: ?Sized,70 {71 self.0.push(value.serialize(MySerialize)?);72 Ok(())73 }7475 fn end(self) -> Result<Self::Ok, Self::Error> {76 Ok(Value::Array(self.0))77 }78}7980pub struct MySerializeSeqVariant(String, MySerializeSeq);8182impl SerializeTupleVariant for MySerializeSeqVariant {83 type Ok = Value;8485 type Error = Error;8687 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>88 where89 T: serde::Serialize,90 T: ?Sized,91 {92 self.1.serialize_field(value)93 }9495 fn end(self) -> Result<Self::Ok, Self::Error> {96 Ok(Value::Object(97 vec![(self.0, Value::Array(self.1.0))].into_iter().collect(),98 ))99 }100}101102pub struct MySerializeMap(LinkedHashMap<String, Value>, Option<String>);103104impl SerializeMap for MySerializeMap {105 type Ok = Value;106107 type Error = Error;108109 fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>110 where111 T: serde::Serialize,112 T: ?Sized,113 {114 let _ = self115 .1116 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());117 Ok(())118 }119120 fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>121 where122 T: serde::Serialize,123 T: ?Sized,124 {125 self.0126 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);127 Ok(())128 }129130 fn end(self) -> Result<Self::Ok, Self::Error> {131 Ok(Value::Object(self.0))132 }133}134135pub struct MySerializeStruct(LinkedHashMap<String, Value>);136137impl SerializeStruct for MySerializeStruct {138 type Ok = Value;139140 type Error = Error;141142 fn serialize_field<T>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>143 where144 T: serde::Serialize,145 T: ?Sized,146 {147 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);148 Ok(())149 }150151 fn end(self) -> Result<Self::Ok, Self::Error> {152 Ok(Value::Object(self.0))153 }154}155156pub struct MySerializeStructVariant(String, LinkedHashMap<String, Value>);157158impl SerializeStructVariant for MySerializeStructVariant {159 type Ok = Value;160161 type Error = Error;162163 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>164 where165 T: serde::Serialize,166 T: ?Sized,167 {168 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);169 Ok(())170 }171172 fn end(self) -> Result<Self::Ok, Self::Error> {173 Ok(Value::Object(174 vec![(self.0, Value::Object(self.1))].into_iter().collect(),175 ))176 }177}178179pub struct MySerialize;180181impl Serializer for MySerialize {182 type Ok = Value;183184 type Error = Error;185186 type SerializeSeq = MySerializeSeq;187188 type SerializeTuple = MySerializeSeq;189190 type SerializeTupleStruct = MySerializeSeq;191192 type SerializeTupleVariant = MySerializeSeqVariant;193194 type SerializeMap = MySerializeMap;195196 type SerializeStruct = MySerializeStruct;197198 type SerializeStructVariant = MySerializeStructVariant;199200 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {201 Ok(Value::Boolean(v))202 }203204 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {205 Ok(Value::Number(v as i64))206 }207208 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {209 Ok(Value::Number(v as i64))210 }211212 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {213 Ok(Value::Number(v as i64))214 }215216 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {217 Ok(Value::Number(v))218 }219220 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {221 Ok(Value::Number(v as i64))222 }223224 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {225 Ok(Value::Number(v as i64))226 }227228 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {229 Ok(Value::Number(v as i64))230 }231232 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {233 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))234 }235236 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {237 todo!()238 }239240 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {241 todo!()242 }243244 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {245 Ok(Value::String(v.to_string()))246 }247248 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {249 Ok(Value::String(v.to_owned()))250 }251252 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {253 todo!()254 }255256 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {257 Ok(Value::Null)258 }259260 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>261 where262 T: serde::Serialize,263 T: ?Sized,264 {265 value.serialize(self)266 }267268 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {269 Ok(Value::Null)270 }271272 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {273 self.serialize_unit()274 }275276 fn serialize_unit_variant(277 self,278 _name: &'static str,279 _variant_index: u32,280 variant: &'static str,281 ) -> Result<Self::Ok, Self::Error> {282 Ok(Value::String(variant.to_string()))283 }284285 fn serialize_newtype_struct<T>(286 self,287 _name: &'static str,288 value: &T,289 ) -> Result<Self::Ok, Self::Error>290 where291 T: serde::Serialize,292 T: ?Sized,293 {294 value.serialize(self)295 }296297 fn serialize_newtype_variant<T>(298 self,299 _name: &'static str,300 _variant_index: u32,301 variant: &'static str,302 value: &T,303 ) -> Result<Self::Ok, Self::Error>304 where305 T: serde::Serialize,306 T: ?Sized,307 {308 Ok(Value::Object(309 vec![(variant.to_string(), value.serialize(self)?)]310 .into_iter()311 .collect(),312 ))313 }314315 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {316 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))317 }318319 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {320 Ok(MySerializeSeq(Vec::with_capacity(len)))321 }322323 fn serialize_tuple_struct(324 self,325 _name: &'static str,326 len: usize,327 ) -> Result<Self::SerializeTupleStruct, Self::Error> {328 Ok(MySerializeSeq(Vec::with_capacity(len)))329 }330331 fn serialize_tuple_variant(332 self,333 _name: &'static str,334 _variant_index: u32,335 variant: &'static str,336 len: usize,337 ) -> Result<Self::SerializeTupleVariant, Self::Error> {338 Ok(MySerializeSeqVariant(339 variant.to_owned(),340 MySerializeSeq(Vec::with_capacity(len)),341 ))342 }343344 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {345 Ok(MySerializeMap(LinkedHashMap::new(), None))346 }347348 fn serialize_struct(349 self,350 _name: &'static str,351 _len: usize,352 ) -> Result<Self::SerializeStruct, Self::Error> {353 Ok(MySerializeStruct(LinkedHashMap::new()))354 }355356 fn serialize_struct_variant(357 self,358 _name: &'static str,359 _variant_index: u32,360 variant: &'static str,361 _len: usize,362 ) -> Result<Self::SerializeStructVariant, Self::Error> {363 Ok(MySerializeStructVariant(364 variant.to_owned(),365 LinkedHashMap::new(),366 ))367 }368}