git.delta.rocks / jrsonnet / refs/commits / f48f507511e2

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 as i64))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}