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: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>31 where32 T: serde::Serialize,33 {34 self.0.push(value.serialize(MySerialize)?);35 Ok(())36 }3738 fn end(self) -> Result<Self::Ok, Self::Error> {39 Ok(Value::Array(self.0))40 }41}42impl SerializeTuple for MySerializeSeq {43 type Ok = Value;4445 type Error = Error;4647 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>48 where49 T: serde::Serialize,50 {51 self.0.push(value.serialize(MySerialize)?);52 Ok(())53 }5455 fn end(self) -> Result<Self::Ok, Self::Error> {56 Ok(Value::Array(self.0))57 }58}59impl SerializeTupleStruct for MySerializeSeq {60 type Ok = Value;6162 type Error = Error;6364 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>65 where66 T: serde::Serialize,67 {68 self.0.push(value.serialize(MySerialize)?);69 Ok(())70 }7172 fn end(self) -> Result<Self::Ok, Self::Error> {73 Ok(Value::Array(self.0))74 }75}7677pub struct MySerializeSeqVariant(String, MySerializeSeq);7879impl SerializeTupleVariant for MySerializeSeqVariant {80 type Ok = Value;8182 type Error = Error;8384 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>85 where86 T: serde::Serialize,87 {88 self.1.serialize_field(value)89 }9091 fn end(self) -> Result<Self::Ok, Self::Error> {92 Ok(Value::Object(93 vec![(self.0, Value::Array(self.1.0))].into_iter().collect(),94 ))95 }96}9798pub struct MySerializeMap(LinkedHashMap<String, Value>, Option<String>);99100impl SerializeMap for MySerializeMap {101 type Ok = Value;102103 type Error = Error;104105 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>106 where107 T: serde::Serialize,108 {109 let _ = self110 .1111 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());112 Ok(())113 }114115 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>116 where117 T: serde::Serialize,118 {119 self.0120 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);121 Ok(())122 }123124 fn end(self) -> Result<Self::Ok, Self::Error> {125 Ok(Value::Object(self.0))126 }127}128129pub struct MySerializeStruct(LinkedHashMap<String, Value>);130131impl SerializeStruct for MySerializeStruct {132 type Ok = Value;133134 type Error = Error;135136 fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>137 where138 T: serde::Serialize,139 {140 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);141 Ok(())142 }143144 fn end(self) -> Result<Self::Ok, Self::Error> {145 Ok(Value::Object(self.0))146 }147}148149pub struct MySerializeStructVariant(String, LinkedHashMap<String, Value>);150151impl SerializeStructVariant for MySerializeStructVariant {152 type Ok = Value;153154 type Error = Error;155156 fn serialize_field<T: ?Sized>(157 &mut self,158 key: &'static str,159 value: &T,160 ) -> Result<(), Self::Error>161 where162 T: serde::Serialize,163 {164 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);165 Ok(())166 }167168 fn end(self) -> Result<Self::Ok, Self::Error> {169 Ok(Value::Object(170 vec![(self.0, Value::Object(self.1))].into_iter().collect(),171 ))172 }173}174175pub struct MySerialize;176177impl Serializer for MySerialize {178 type Ok = Value;179180 type Error = Error;181182 type SerializeSeq = MySerializeSeq;183184 type SerializeTuple = MySerializeSeq;185186 type SerializeTupleStruct = MySerializeSeq;187188 type SerializeTupleVariant = MySerializeSeqVariant;189190 type SerializeMap = MySerializeMap;191192 type SerializeStruct = MySerializeStruct;193194 type SerializeStructVariant = MySerializeStructVariant;195196 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {197 Ok(Value::Boolean(v))198 }199200 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {201 Ok(Value::Number(v as i64))202 }203204 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {205 Ok(Value::Number(v as i64))206 }207208 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {209 Ok(Value::Number(v as i64))210 }211212 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {213 Ok(Value::Number(v))214 }215216 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {217 Ok(Value::Number(v as i64))218 }219220 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {221 Ok(Value::Number(v as i64))222 }223224 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {225 Ok(Value::Number(v as i64))226 }227228 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {229 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))230 }231232 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {233 todo!()234 }235236 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {237 todo!()238 }239240 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {241 Ok(Value::String(v.to_string()))242 }243244 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {245 Ok(Value::String(v.to_owned()))246 }247248 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {249 todo!()250 }251252 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {253 Ok(Value::Null)254 }255256 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>257 where258 T: serde::Serialize,259 {260 value.serialize(self)261 }262263 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {264 Ok(Value::Null)265 }266267 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {268 self.serialize_unit()269 }270271 fn serialize_unit_variant(272 self,273 _name: &'static str,274 _variant_index: u32,275 variant: &'static str,276 ) -> Result<Self::Ok, Self::Error> {277 Ok(Value::String(variant.to_string()))278 }279280 fn serialize_newtype_struct<T: ?Sized>(281 self,282 _name: &'static str,283 value: &T,284 ) -> Result<Self::Ok, Self::Error>285 where286 T: serde::Serialize,287 {288 value.serialize(self)289 }290291 fn serialize_newtype_variant<T: ?Sized>(292 self,293 _name: &'static str,294 _variant_index: u32,295 variant: &'static str,296 value: &T,297 ) -> Result<Self::Ok, Self::Error>298 where299 T: serde::Serialize,300 {301 Ok(Value::Object(302 vec![(variant.to_string(), value.serialize(self)?)]303 .into_iter()304 .collect(),305 ))306 }307308 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {309 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))310 }311312 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {313 Ok(MySerializeSeq(Vec::with_capacity(len)))314 }315316 fn serialize_tuple_struct(317 self,318 _name: &'static str,319 len: usize,320 ) -> Result<Self::SerializeTupleStruct, Self::Error> {321 Ok(MySerializeSeq(Vec::with_capacity(len)))322 }323324 fn serialize_tuple_variant(325 self,326 _name: &'static str,327 _variant_index: u32,328 variant: &'static str,329 len: usize,330 ) -> Result<Self::SerializeTupleVariant, Self::Error> {331 Ok(MySerializeSeqVariant(332 variant.to_owned(),333 MySerializeSeq(Vec::with_capacity(len)),334 ))335 }336337 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {338 Ok(MySerializeMap(LinkedHashMap::new(), None))339 }340341 fn serialize_struct(342 self,343 _name: &'static str,344 _len: usize,345 ) -> Result<Self::SerializeStruct, Self::Error> {346 Ok(MySerializeStruct(LinkedHashMap::new()))347 }348349 fn serialize_struct_variant(350 self,351 _name: &'static str,352 _variant_index: u32,353 variant: &'static str,354 _len: usize,355 ) -> Result<Self::SerializeStructVariant, Self::Error> {356 Ok(MySerializeStructVariant(357 variant.to_owned(),358 LinkedHashMap::new(),359 ))360 }361}