1use std::{collections::BTreeMap, convert::TryInto};23use serde::{4 ser::{5 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,6 SerializeTupleStruct, SerializeTupleVariant,7 },8 Serializer,9};1011use crate::{Error, Value};1213impl ser::Error for Error {14 fn custom<T>(msg: T) -> Self15 where16 T: std::fmt::Display,17 {18 Self::Custom(format!("{}", msg))19 }20}2122pub struct MySerializeSeq(Vec<Value>);2324impl SerializeSeq for MySerializeSeq {25 type Ok = Value;2627 type Error = Error;2829 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>30 where31 T: serde::Serialize,32 {33 self.0.push(value.serialize(MySerialize)?);34 Ok(())35 }3637 fn end(self) -> Result<Self::Ok, Self::Error> {38 Ok(Value::Array(self.0))39 }40}41impl SerializeTuple for MySerializeSeq {42 type Ok = Value;4344 type Error = Error;4546 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>47 where48 T: serde::Serialize,49 {50 self.0.push(value.serialize(MySerialize)?);51 Ok(())52 }5354 fn end(self) -> Result<Self::Ok, Self::Error> {55 Ok(Value::Array(self.0))56 }57}58impl SerializeTupleStruct for MySerializeSeq {59 type Ok = Value;6061 type Error = Error;6263 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>64 where65 T: serde::Serialize,66 {67 self.0.push(value.serialize(MySerialize)?);68 Ok(())69 }7071 fn end(self) -> Result<Self::Ok, Self::Error> {72 Ok(Value::Array(self.0))73 }74}7576pub struct MySerializeSeqVariant(String, MySerializeSeq);7778impl SerializeTupleVariant for MySerializeSeqVariant {79 type Ok = Value;8081 type Error = Error;8283 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>84 where85 T: serde::Serialize,86 {87 self.1.serialize_field(value)88 }8990 fn end(self) -> Result<Self::Ok, Self::Error> {91 Ok(Value::Object(92 vec![(self.0, Value::Array(self.1 .0))]93 .into_iter()94 .collect(),95 ))96 }97}9899pub struct MySerializeMap(BTreeMap<String, Value>, Option<String>);100101impl SerializeMap for MySerializeMap {102 type Ok = Value;103104 type Error = Error;105106 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>107 where108 T: serde::Serialize,109 {110 let _ = self111 .1112 .insert(key.serialize(MySerialize)?.parse_string()?.to_owned());113 Ok(())114 }115116 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>117 where118 T: serde::Serialize,119 {120 self.0121 .insert(self.1.take().unwrap(), value.serialize(MySerialize)?);122 Ok(())123 }124125 fn end(self) -> Result<Self::Ok, Self::Error> {126 Ok(Value::Object(self.0))127 }128}129130pub struct MySerializeStruct(BTreeMap<String, Value>);131132impl SerializeStruct for MySerializeStruct {133 type Ok = Value;134135 type Error = Error;136137 fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>138 where139 T: serde::Serialize,140 {141 self.0.insert(key.to_owned(), value.serialize(MySerialize)?);142 Ok(())143 }144145 fn end(self) -> Result<Self::Ok, Self::Error> {146 Ok(Value::Object(self.0))147 }148}149150pub struct MySerializeStructVariant(String, BTreeMap<String, Value>);151152impl SerializeStructVariant for MySerializeStructVariant {153 type Ok = Value;154155 type Error = Error;156157 fn serialize_field<T: ?Sized>(158 &mut self,159 key: &'static str,160 value: &T,161 ) -> Result<(), Self::Error>162 where163 T: serde::Serialize,164 {165 self.1.insert(key.to_owned(), value.serialize(MySerialize)?);166 Ok(())167 }168169 fn end(self) -> Result<Self::Ok, Self::Error> {170 Ok(Value::Object(171 vec![(self.0, Value::Object(self.1))].into_iter().collect(),172 ))173 }174}175176pub struct MySerialize;177178impl Serializer for MySerialize {179 type Ok = Value;180181 type Error = Error;182183 type SerializeSeq = MySerializeSeq;184185 type SerializeTuple = MySerializeSeq;186187 type SerializeTupleStruct = MySerializeSeq;188189 type SerializeTupleVariant = MySerializeSeqVariant;190191 type SerializeMap = MySerializeMap;192193 type SerializeStruct = MySerializeStruct;194195 type SerializeStructVariant = MySerializeStructVariant;196197 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {198 Ok(Value::Boolean(v))199 }200201 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {202 Ok(Value::Number(v as i64))203 }204205 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {206 Ok(Value::Number(v as i64))207 }208209 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {210 Ok(Value::Number(v as i64))211 }212213 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {214 Ok(Value::Number(v as i64))215 }216217 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {218 Ok(Value::Number(v as i64))219 }220221 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {222 Ok(Value::Number(v as i64))223 }224225 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {226 Ok(Value::Number(v as i64))227 }228229 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {230 Ok(Value::Number(v.try_into().map_err(|_| Error::BadNumber)?))231 }232233 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {234 todo!()235 }236237 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {238 todo!()239 }240241 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {242 Ok(Value::String(v.to_string()))243 }244245 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {246 Ok(Value::String(v.to_owned()))247 }248249 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {250 todo!()251 }252253 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {254 Ok(Value::Null)255 }256257 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>258 where259 T: serde::Serialize,260 {261 value.serialize(self)262 }263264 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {265 Ok(Value::Null)266 }267268 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {269 self.serialize_unit()270 }271272 fn serialize_unit_variant(273 self,274 _name: &'static str,275 _variant_index: u32,276 variant: &'static str,277 ) -> Result<Self::Ok, Self::Error> {278 Ok(Value::String(variant.to_string()))279 }280281 fn serialize_newtype_struct<T: ?Sized>(282 self,283 _name: &'static str,284 value: &T,285 ) -> Result<Self::Ok, Self::Error>286 where287 T: serde::Serialize,288 {289 value.serialize(self)290 }291292 fn serialize_newtype_variant<T: ?Sized>(293 self,294 _name: &'static str,295 _variant_index: u32,296 variant: &'static str,297 value: &T,298 ) -> Result<Self::Ok, Self::Error>299 where300 T: serde::Serialize,301 {302 Ok(Value::Object(303 vec![(variant.to_string(), value.serialize(self)?)]304 .into_iter()305 .collect(),306 ))307 }308309 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {310 Ok(MySerializeSeq(Vec::with_capacity(len.unwrap_or_default())))311 }312313 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {314 Ok(MySerializeSeq(Vec::with_capacity(len)))315 }316317 fn serialize_tuple_struct(318 self,319 _name: &'static str,320 len: usize,321 ) -> Result<Self::SerializeTupleStruct, Self::Error> {322 Ok(MySerializeSeq(Vec::with_capacity(len)))323 }324325 fn serialize_tuple_variant(326 self,327 _name: &'static str,328 _variant_index: u32,329 variant: &'static str,330 len: usize,331 ) -> Result<Self::SerializeTupleVariant, Self::Error> {332 Ok(MySerializeSeqVariant(333 variant.to_owned(),334 MySerializeSeq(Vec::with_capacity(len)),335 ))336 }337338 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {339 Ok(MySerializeMap(BTreeMap::new(), None))340 }341342 fn serialize_struct(343 self,344 _name: &'static str,345 _len: usize,346 ) -> Result<Self::SerializeStruct, Self::Error> {347 Ok(MySerializeStruct(BTreeMap::new()))348 }349350 fn serialize_struct_variant(351 self,352 _name: &'static str,353 _variant_index: u32,354 variant: &'static str,355 _len: usize,356 ) -> Result<Self::SerializeStructVariant, Self::Error> {357 Ok(MySerializeStructVariant(358 variant.to_owned(),359 BTreeMap::new(),360 ))361 }362}