move rust-sciter in

libs/rust-sciter/serde/src/ser.rs

@@ -0,0 +1,345 @@
+/// Serialization.
+use serde::ser::{self, Serialize};
+
+use error::{Error, Result};
+use sciter::{Value};
+
+
+/// Serialize the given data structure into Sciter value.
+pub fn to_value<T: ?Sized + Serialize>(value: &T) -> Result<Value> {
+	let mut p = Serializer { output: Value::new() };
+	value.serialize(&mut p)?;
+	Ok(p.output)
+}
+
+/// Implementation of serialization.
+pub struct Serializer {
+	output: Value,
+}
+
+// Helper structure for serialization of sequence data types (array, map, tuple ans so on).
+#[doc(hidden)]
+pub struct SeqSerializer<'a> {
+	ser: &'a mut Serializer,
+	output: Value,
+	key: Option<Value>,
+	outer: Option<Value>,
+}
+
+impl<'a> SeqSerializer<'a> {
+	fn typed(ser: &'a mut Serializer, typed: Value) -> Self {
+		SeqSerializer {
+			ser: ser,
+			output: typed,
+			key: None,
+			outer: None,
+		}
+	}
+
+	fn with_outer(ser: &'a mut Serializer, outer: Value, typed: Value) -> Self {
+		SeqSerializer {
+			ser: ser,
+			output: typed,
+			key: None,
+			outer: Some(outer),
+		}
+	}
+}
+
+// serde traits implementation
+
+impl<'a> ser::SerializeSeq for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		self.ser.output = self.output;
+		Ok(())
+	}
+
+	fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
+		let dst = to_value(value)?;
+		self.output.push(dst);
+		Ok(())
+	}
+}
+
+impl<'a> ser::SerializeMap for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		ser::SerializeSeq::end(self)
+	}
+
+	fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()> where K: ?Sized + Serialize, V: ?Sized + Serialize {
+		self.output.set_item(to_value(key)?, to_value(value)?);
+		Ok(())
+	}
+
+	fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<()> {
+		self.key = Some(to_value(key)?);
+		Ok(())
+	}
+
+	fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
+		let key = self.key.take();
+		self.output.set_item(key.unwrap(), to_value(value)?);
+		Ok(())
+	}
+}
+
+impl<'a> ser::SerializeStruct for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		ser::SerializeSeq::end(self)
+	}
+
+	fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<()> {
+		self.output.set_item(key, to_value(value)?);
+		Ok(())
+	}
+}
+
+impl<'a> ser::SerializeStructVariant for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		// self.output: map
+		// self.outer: left key
+		let mut result = Value::new();
+		result.set_item(self.outer.unwrap(), self.output);
+		self.ser.output = result;
+		Ok(())
+	}
+
+	fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<()> {
+		self.output.set_item(key, to_value(value)?);
+		Ok(())
+	}
+}
+
+impl<'a> ser::SerializeTuple for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		ser::SerializeSeq::end(self)
+	}
+
+	fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
+		ser::SerializeSeq::serialize_element(self, value)
+	}
+}
+
+impl<'a> ser::SerializeTupleStruct for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		ser::SerializeSeq::end(self)
+	}
+
+	fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
+		ser::SerializeSeq::serialize_element(self, value)
+	}
+}
+
+impl<'a> ser::SerializeTupleVariant for SeqSerializer<'a> {
+	type Ok = ();
+	type Error = Error;
+
+	fn end(self) -> Result<()> {
+		// self.output: array
+		// self.outer: left key
+		let mut result = Value::new();
+		result.set_item(self.outer.unwrap(), self.output);
+		self.ser.output = result;
+		Ok(())
+	}
+
+	fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
+		ser::SerializeSeq::serialize_element(self, value)
+	}
+}
+
+
+impl<'a> ser::Serializer for &'a mut Serializer {
+	type Ok = ();
+	type Error = Error;
+
+  type SerializeSeq = SeqSerializer<'a>;
+  type SerializeTuple = SeqSerializer<'a>;
+  type SerializeTupleStruct = SeqSerializer<'a>;
+  type SerializeTupleVariant = SeqSerializer<'a>;
+  type SerializeMap = SeqSerializer<'a>;
+  type SerializeStruct = SeqSerializer<'a>;
+  type SerializeStructVariant = SeqSerializer<'a>;
+
+
+  fn serialize_bool(self, v: bool) -> Result<()> {
+  	self.output = v.into();
+  	Ok(())
+  }
+
+  fn serialize_i8(self, v: i8) -> Result<()> {
+  	self.serialize_i32(v as i32)
+  }
+
+  fn serialize_i16(self, v: i16) -> Result<()> {
+  	self.serialize_i32(v as i32)
+  }
+
+  fn serialize_i32(self, v: i32) -> Result<()> {
+  	self.output = v.into();
+  	Ok(())
+  }
+
+  fn serialize_u8(self, v: u8) -> Result<()> {
+  	self.serialize_i32(v as i32)
+  }
+
+  fn serialize_u16(self, v: u16) -> Result<()> {
+  	self.serialize_i32(v as i32)
+  }
+
+  fn serialize_u32(self, v: u32) -> Result<()> {
+  	if v <= i32::max_value() as u32 {
+  		self.serialize_i32(v as i32)
+  	} else {
+  		self.serialize_f64(v as f64)
+  	}
+  }
+
+  fn serialize_i64(self, _v: i64) -> Result<()> {
+  	Err(Error::UnsupportedType)
+  }
+
+  fn serialize_u64(self, _v: u64) -> Result<()> {
+  	Err(Error::UnsupportedType)
+  }
+
+  // Float values.
+  fn serialize_f32(self, v: f32) -> Result<()> {
+  	self.serialize_f64(v as f64)
+  }
+
+  fn serialize_f64(self, v: f64) -> Result<()> {
+  	self.output = v.into();
+  	Ok(())
+  }
+
+  // A single character is passed as a string.
+  fn serialize_char(self, v: char) -> Result<()> {
+  	self.serialize_str(&v.to_string())
+  }
+
+  // String itself.
+  fn serialize_str(self, v: &str) -> Result<()> {
+  	self.output = v.into();
+  	Ok(())
+  }
+
+  // Binary bytes.
+  fn serialize_bytes(self, v: &[u8]) -> Result<()> {
+  	self.output = Value::from(v);
+  	Ok(())
+  }
+
+  // A `None` value of `Option` type in Rust.
+  fn serialize_none(self) -> Result<()> {
+  	self.output = Value::null();
+  	Ok(())
+  }
+
+  // Some value of `Option` type in Rust.
+  fn serialize_some<T>(self, v: &T) -> Result<()> where T: ?Sized + Serialize {
+  	v.serialize(self)
+  }
+
+  // The type of `()` in Rust.
+  fn serialize_unit(self) -> Result<()> {
+  	self.serialize_none()
+  }
+
+  // A named value containing no data, like `struct Unit;`.
+  fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+  	self.serialize_none()
+  }
+
+  // Enums. Serialized as an externally tagged enum representation,
+  // see https://serde.rs/enum-representations.html.
+
+  // A unit variant of enum, like `E::A` of `enum E { A, B }`.
+  fn serialize_unit_variant(self, _name: &'static str, _index: u32, value: &'static str)
+  	-> Result<()>
+  {
+  	// `"A"`
+  	self.serialize_str(value)
+  }
+
+  // For example the `E::N` in `enum E { N(u8) }`.
+  fn serialize_newtype_variant<T>(self, _name: &'static str, _index: u32, variant: &'static str, value: &T)
+  	-> Result<()> where T: ?Sized + Serialize
+  {
+  	// `{ "N": u8 }`
+  	self.output.set_item(to_value(variant)?, to_value(value)?);
+  	Ok(())
+  }
+
+  // For example the `E::T` in `enum E { T(u8, u8) }`.
+  fn serialize_tuple_variant(self, _name: &'static str, _index: u32, value: &'static str, _len: usize)
+  	 -> Result<Self::SerializeTupleVariant>
+  {
+  	// `{ "T": [u8, u8] }`
+  	let left = to_value(value)?;
+  	Ok(SeqSerializer::with_outer(self, left, Value::array(0)))
+  }
+
+  // For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
+  fn serialize_struct_variant(self, _name: &'static str, _index: u32, value: &'static str, _len: usize)
+  	 -> Result<Self::SerializeStructVariant>
+  {
+  	// `{ "S": {r: u8, g: u8, b: u8} }`
+  	let left = to_value(value)?;
+  	Ok(SeqSerializer::with_outer(self, left, Value::map()))
+  }
+
+  // New-type struct, like `struct Celcius(u32)`.
+  fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
+  	where T: ?Sized + Serialize
+  {
+  	// Serialize the inner itself.
+  	value.serialize(self)
+  }
+
+  // A variably sized heterogeneous sequence of values, for example `Vec<T>` or `HashSet<T>`.
+  fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+  	// let init = if let Some(size) = len { Value::array(size) } else { Value::new() };
+  	Ok(SeqSerializer::typed(self, Value::array(0)))
+  }
+
+  // A statically sized heterogeneous sequence of values, `[u64; 10]`, `(u8,)` or `(String, u64, Vec<T>)`.
+  fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
+  	self.serialize_seq(Some(len))
+  }
+
+  // A named tuple, for example `struct Rgb(u8, u8, u8)`.
+  fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
+  	self.serialize_seq(Some(len))
+  }
+
+  // A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
+  fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+  	Ok(SeqSerializer::typed(self, Value::map()))
+  }
+
+  // A heterogeneous key-value pairing , for example `struct S { r: u8, g: u8, b: u8 }`.
+  fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+  	self.serialize_map(Some(len))
+  }
+
+}