1use std::convert::TryInto;23use linked_hash_map::LinkedHashMap;4use serde::{5 ser::{6 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,7 SerializeTupleStruct, SerializeTupleVariant,8 },9 Serializer,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))]94 .into_iter()95 .collect(),96 ))97 }98}99100pub struct MySerializeMap(LinkedHashMap<String, Value>, Option<String>);101102impl SerializeMap for MySerializeMap {103 type Ok = Value;104105 type Error = Error;106107 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>108 where109 T: serde::Serialize,110 {111 let _ = self112 .1113 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());114 Ok(())115 }116117 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>118 where119 T: serde::Serialize,120 {121 self.0122 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);123 Ok(())124 }125126 fn end(self) -> Result<Self::Ok, Self::Error> {127 Ok(Value::Object(self.0))128 }129}130131pub struct MySerializeStruct(LinkedHashMap<String, Value>);132133impl SerializeStruct for MySerializeStruct {134 type Ok = Value;135136 type Error = Error;137138 fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>139 where140 T: serde::Serialize,141 {142 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);143 Ok(())144 }145146 fn end(self) -> Result<Self::Ok, Self::Error> {147 Ok(Value::Object(self.0))148 }149}150151pub struct MySerializeStructVariant(String, LinkedHashMap<String, Value>);152153impl SerializeStructVariant for MySerializeStructVariant {154 type Ok = Value;155156 type Error = Error;157158 fn serialize_field<T: ?Sized>(159 &mut self,160 key: &'static str,161 value: &T,162 ) -> Result<(), Self::Error>163 where164 T: serde::Serialize,165 {166 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);167 Ok(())168 }169170 fn end(self) -> Result<Self::Ok, Self::Error> {171 Ok(Value::Object(172 vec![(self.0, Value::Object(self.1))].into_iter().collect(),173 ))174 }175}176177pub struct MySerialize;178179impl Serializer for MySerialize {180 type Ok = Value;181182 type Error = Error;183184 type SerializeSeq = MySerializeSeq;185186 type SerializeTuple = MySerializeSeq;187188 type SerializeTupleStruct = MySerializeSeq;189190 type SerializeTupleVariant = MySerializeSeqVariant;191192 type SerializeMap = MySerializeMap;193194 type SerializeStruct = MySerializeStruct;195196 type SerializeStructVariant = MySerializeStructVariant;197198 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {199 Ok(Value::Boolean(v))200 }201202 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {203 Ok(Value::Number(v as i64))204 }205206 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {207 Ok(Value::Number(v as i64))208 }209210 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {211 Ok(Value::Number(v as i64))212 }213214 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {215 Ok(Value::Number(v))216 }217218 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {219 Ok(Value::Number(v as i64))220 }221222 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {223 Ok(Value::Number(v as i64))224 }225226 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {227 Ok(Value::Number(v as i64))228 }229230 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {231 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))232 }233234 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {235 todo!()236 }237238 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {239 todo!()240 }241242 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {243 Ok(Value::String(v.to_string()))244 }245246 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {247 Ok(Value::String(v.to_owned()))248 }249250 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {251 todo!()252 }253254 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {255 Ok(Value::Null)256 }257258 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>259 where260 T: serde::Serialize,261 {262 value.serialize(self)263 }264265 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {266 Ok(Value::Null)267 }268269 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {270 self.serialize_unit()271 }272273 fn serialize_unit_variant(274 self,275 _name: &'static str,276 _variant_index: u32,277 variant: &'static str,278 ) -> Result<Self::Ok, Self::Error> {279 Ok(Value::String(variant.to_string()))280 }281282 fn serialize_newtype_struct<T: ?Sized>(283 self,284 _name: &'static str,285 value: &T,286 ) -> Result<Self::Ok, Self::Error>287 where288 T: serde::Serialize,289 {290 value.serialize(self)291 }292293 fn serialize_newtype_variant<T: ?Sized>(294 self,295 _name: &'static str,296 _variant_index: u32,297 variant: &'static str,298 value: &T,299 ) -> Result<Self::Ok, Self::Error>300 where301 T: serde::Serialize,302 {303 Ok(Value::Object(304 vec![(variant.to_string(), value.serialize(self)?)]305 .into_iter()306 .collect(),307 ))308 }309310 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {311 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))312 }313314 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {315 Ok(MySerializeSeq(Vec::with_capacity(len)))316 }317318 fn serialize_tuple_struct(319 self,320 _name: &'static str,321 len: usize,322 ) -> Result<Self::SerializeTupleStruct, Self::Error> {323 Ok(MySerializeSeq(Vec::with_capacity(len)))324 }325326 fn serialize_tuple_variant(327 self,328 _name: &'static str,329 _variant_index: u32,330 variant: &'static str,331 len: usize,332 ) -> Result<Self::SerializeTupleVariant, Self::Error> {333 Ok(MySerializeSeqVariant(334 variant.to_owned(),335 MySerializeSeq(Vec::with_capacity(len)),336 ))337 }338339 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {340 Ok(MySerializeMap(LinkedHashMap::new(), None))341 }342343 fn serialize_struct(344 self,345 _name: &'static str,346 _len: usize,347 ) -> Result<Self::SerializeStruct, Self::Error> {348 Ok(MySerializeStruct(LinkedHashMap::new()))349 }350351 fn serialize_struct_variant(352 self,353 _name: &'static str,354 _variant_index: u32,355 variant: &'static str,356 _len: usize,357 ) -> Result<Self::SerializeStructVariant, Self::Error> {358 Ok(MySerializeStructVariant(359 variant.to_owned(),360 LinkedHashMap::new(),361 ))362 }363}