git.delta.rocks / jrsonnet / refs/commits / 34f0c725e4c0

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}