move rust-sciter in

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

@@ -0,0 +1,278 @@
+/// Deserialization.
+use serde::de::{self, Deserialize, Visitor};
+
+use error::{Error, Result};
+use sciter::{Value};
+
+
+/// Deserializes a Sciter value to the specific Rust type.
+pub fn from_value<'a, T>(input: &'a Value) -> Result<T>
+	where T: Deserialize<'a>
+{
+	let p = Deserializer::from_value(input.clone());
+	T::deserialize(p)
+}
+
+
+/// Implementation of deserialization.
+pub struct Deserializer {
+	input: Value,
+}
+
+
+impl<'de> Deserializer {
+
+	pub fn from_value(input: Value) -> Self {
+		Deserializer { input: input }
+	}
+}
+
+
+impl<'de, 'a> ::serde::de::Deserializer<'de> for Deserializer {
+	type Error = Error;
+
+
+	fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value>
+	{
+		use sciter::value::VALUE_TYPE;
+		match self.input.get_type() {
+			VALUE_TYPE::T_UNDEFINED|VALUE_TYPE::T_NULL => visitor.visit_none(),
+			VALUE_TYPE::T_BOOL => visitor.visit_bool(self.input.to_bool().unwrap()),
+			VALUE_TYPE::T_INT => visitor.visit_i32(self.input.to_int().unwrap()),
+			VALUE_TYPE::T_FLOAT => visitor.visit_f64(self.input.to_float().unwrap()),
+			VALUE_TYPE::T_STRING => visitor.visit_str(&self.input.as_string().unwrap()),
+			VALUE_TYPE::T_ARRAY => visitor.visit_seq(SeqAccess::new(self)),
+			VALUE_TYPE::T_MAP => self.deserialize_map(visitor),
+			VALUE_TYPE::T_BYTES => visitor.visit_bytes(self.input.as_bytes().unwrap()),
+			VALUE_TYPE::T_OBJECT => self.deserialize_map(visitor),
+			_ => Err(Error::UnsupportedType),
+		}
+	}
+
+	fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value>	{
+		self.deserialize_any(visitor)
+	}
+
+	fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+		if let Some(v) = self.input.to_bool() {
+			visitor.visit_bool(v)
+		} else {
+			Err(Error::ExpectedType(format!("expected {:?}, given {:?}", "bool", self.input)))
+		}
+	}
+
+	forward_to_deserialize_any! {
+		i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes	byte_buf
+	}
+
+	fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+		if self.input.is_undefined() || self.input.is_null() {
+			visitor.visit_none()
+		} else {
+			visitor.visit_some(self)
+		}
+	}
+
+	fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+		if self.input.is_undefined() || self.input.is_null() {
+			visitor.visit_unit()
+		} else {
+			Err(Error::ExpectedType(format!("expected {:?}, given {:?}", "null", self.input)))
+		}
+	}
+
+	fn deserialize_unit_struct<V: Visitor<'de>>(self, _name: &'static str, visitor: V) -> Result<V::Value> {
+		self.deserialize_unit(visitor)
+	}
+
+	fn deserialize_newtype_struct<V: Visitor<'de>>(self, _name: &str, visitor: V) -> Result<V::Value> {
+		visitor.visit_newtype_struct(self)
+	}
+
+	fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value>	{
+		if self.input.is_array() {
+			let it = self.input.values();
+			let sq = de::value::SeqDeserializer::new(it);
+			visitor.visit_seq(sq)
+		} else {
+			Err(Error::ExpectedType(format!("expected {:?}, given {:?}", "sequence", self.input)))
+		}
+	}
+
+	fn deserialize_tuple<V: Visitor<'de>>(self, _len: usize, visitor: V) -> Result<V::Value> {
+		self.deserialize_seq(visitor)
+	}
+
+	fn deserialize_tuple_struct<V: Visitor<'de>>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value> {
+		self.deserialize_seq(visitor)
+	}
+
+	fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+		if self.input.is_map() {
+			let it = self.input.items().into_iter();
+			let sq = de::value::MapDeserializer::new(it);
+			visitor.visit_map(sq)
+		} else {
+			Err(Error::ExpectedType(format!("expected {:?}, given {:?}", "map", self.input)))
+		}
+	}
+
+	fn deserialize_struct<V: Visitor<'de>>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+	{
+		self.deserialize_map(visitor)
+	}
+
+	fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value>
+	{
+		self.deserialize_str(visitor)
+	}
+
+	fn deserialize_enum<V: Visitor<'de>>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+	{
+		// it can be `"A"`, `{"T": u8}`, `{S: {"x": u8}}`
+		match (self.input.is_string(), self.input.is_map()) {
+
+			(true, _) => {
+				use self::de::IntoDeserializer;
+				visitor.visit_enum(self.input.as_string().unwrap().into_deserializer())
+			},
+
+			(_, true) => {
+				visitor.visit_enum(SeqAccess::new(self))
+			},
+
+			_ => {
+				Err(Error::ExpectedType(format!("expected enum (as string or map), given {:?}", self.input)))
+			}
+		}
+	}
+}
+
+
+impl<'de> de::IntoDeserializer<'de, Error> for Value {
+	type Deserializer = Deserializer;
+
+	fn into_deserializer(self) -> Self::Deserializer {
+		Deserializer::from_value(self)
+	}
+}
+
+
+#[doc(hidden)]
+struct SeqAccess {
+	de: Deserializer,
+	pos: usize,
+	len: usize,
+	key: Option<Value>,
+}
+
+impl SeqAccess {
+	fn new(d: Deserializer) -> Self	{
+		let len = d.input.len();
+		SeqAccess {
+			de: d,
+			pos: 0,
+			len: len,
+			key: None,
+		}
+	}
+}
+
+impl<'de> de::SeqAccess<'de> for SeqAccess {
+	type Error = Error;
+
+	fn size_hint(&self) -> Option<usize> {
+		Some(self.len)
+	}
+
+	fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+		where T: de::DeserializeSeed<'de>
+	{
+		if self.pos < self.len {
+			self.pos += 1;
+			let v = self.de.input.get(self.pos - 1);
+			let inner = Deserializer::from_value(v);
+			seed.deserialize(inner).map(Some)
+		} else {
+			Ok(None)
+		}
+	}
+}
+
+impl<'de> de::MapAccess<'de> for SeqAccess {
+	type Error = Error;
+
+	fn size_hint(&self) -> Option<usize> {
+		Some(self.len)
+	}
+
+	fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+		where K: de::DeserializeSeed<'de>
+	{
+		if self.pos < self.len {
+			self.pos += 1;
+			let v = self.de.input.key_at(self.pos - 1);
+			let inner = Deserializer::from_value(v);
+			seed.deserialize(inner).map(Some)
+		} else {
+			Ok(None)
+		}
+	}
+
+	fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+		where V: de::DeserializeSeed<'de>
+	{
+		let v = self.de.input.get(self.pos - 1);
+		let inner = Deserializer::from_value(v);
+		seed.deserialize(inner)
+	}
+}
+
+impl<'de> de::EnumAccess<'de> for SeqAccess {
+	type Error = Error;
+	type Variant = Self;
+
+	fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant)>
+		where V: de::DeserializeSeed<'de>
+	{
+		// `{ "N": ... }`
+		// Here I suppose to deserialize the variant key.
+		let v = self.de.input.key_at(0);
+		self.key = Some(v.clone());
+		let vkey = seed.deserialize( Deserializer::from_value(v) )?;
+		Ok((vkey, self))
+	}
+}
+
+impl<'de> de::VariantAccess<'de> for SeqAccess {
+	type Error = Error;
+
+	fn unit_variant(self) -> Result<()> {
+		de::Deserialize::deserialize(self.de)
+	}
+
+	fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
+		where T: de::DeserializeSeed<'de>
+	{
+		// `{ "N": u8 }`
+		let v = self.de.input.get_item(self.key.unwrap());
+		seed.deserialize( Deserializer::from_value(v) )
+	}
+
+	fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
+		where V: de::Visitor<'de>
+	{
+		// `{ "T": [u8, u8] }`
+		let v = self.de.input.get_item(self.key.unwrap());
+		de::Deserializer::deserialize_tuple(Deserializer::from_value(v), len, visitor)
+	}
+
+	fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+		where V: de::Visitor<'de>
+	{
+		// `{ "S": {r: u8, g: u8, b: u8} }`
+		let v = self.de.input.get_item(self.key.unwrap());
+		de::Deserializer::deserialize_struct(Deserializer::from_value(v), "", fields, visitor)
+	}
+
+}

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

@@ -0,0 +1,51 @@
+use std;
+use std::fmt::{self, Display};
+
+use serde::{ser, de};
+
+
+/// Result type for serialization.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type for serialization.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Error {
+	Message(String),
+	Unimplemented,
+	UnsupportedType,
+	ExpectedType(String),
+}
+
+impl ser::Error for Error {
+	fn custom<T: Display>(msg: T) -> Self {
+		Error::Message(msg.to_string())
+	}
+}
+
+impl de::Error for Error {
+	fn custom<T: Display>(msg: T) -> Self {
+		Error::Message(msg.to_string())
+	}
+}
+
+impl std::error::Error for Error {
+	fn description(&self) -> &str {
+		match *self {
+			Error::Message(ref msg) => msg,
+			Error::ExpectedType(ref msg) => msg,
+			Error::Unimplemented => "unimplemented",
+			Error::UnsupportedType => "unsupported",
+		}
+	}
+}
+
+impl Display for Error {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			Error::Message(ref msg) => write!(f, "error: {}", msg),
+			Error::ExpectedType(ref msg) => write!(f, "expected: {}", msg),
+			Error::UnsupportedType => write!(f, "unsupported type"),
+			Error::Unimplemented => write!(f, "unimplemented"),
+		}
+	}
+}

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

@@ -0,0 +1,155 @@
+// This component uses Sciter Engine,
+// copyright Terra Informatica Software, Inc.
+// (http://terrainformatica.com/).
+
+/*!
+
+[Serde](https://docs.rs/serde) support for [Sciter](https://docs.rs/sciter-rs) engine.
+
+While technically you could just use the `serde_json` crate and perform serialization via
+an intermediate string (something like `sciter::Value::from_str(&serde_json::to_string(<your data>)?)?`),
+you can also use direct serialization between your data and `sciter::Value`.
+
+## Supported types of Sciter value
+
++ Bool (`bool`)
++ Integer (`i8`-`i32`)
++	Float (`f32`-`f64`)
++ String (`&str`, `String`)
++ Bytes (`&[u8]`)
++ Array (`&[T]`, `Vec<T>`)
++ Object (key-value mapping like `struct` or `HashMap`, `BTreeMap`, etc.)
+
+Unsupported:
+
+- Date
+- Currency
+- Length
+- Range
+- Duration
+- Angle
+- Color
+
+## Supported types of the Serde data model
+
+* [x] `bool`
+* [x] integer types except the following:
+* [-] `i64`/`u64` - 64-bit integers stored as `f64` in Sciter
+* [x] strings
+* [x] byte arrays
+* [x] option
+* [x] unit (stored as `null`)
+* [x] unit struct (stored as `null`)
+* [x] unit variant (aka `enum`, stored just as enum index of `i32` type)
+* [x] newtype struct (aka `struct Io(u32)`, stored as underlaying value)
+* [-] newtype variant
+* [x] seq, like vector (stored as array)
+* [x] tuple (stored as array)
+* [x] tuple struct (stored as array)
+* [-] tuple variant
+* [x] map (stored as map)
+* [x] struct (stored as map)
+* [-] struct variant
+
+See the [Serde data model](https://serde.rs/data-model.html) for reference.
+
+# Examples
+
+```rust
+extern crate sciter;
+extern crate sciter_serde;
+
+use sciter::Value;
+use sciter_serde::{from_value, to_value};
+
+fn back_and_forth() {
+	let v: Value = to_value(&true).unwrap();
+	let b: bool = from_value(&v).unwrap();
+	assert_eq!(b, true);
+}
+
+fn main() {
+
+	// bool
+	let v: Value = to_value(&true).unwrap();
+	assert!(v.is_bool());
+	assert_eq!(v, Value::from(true));
+
+	// numbers
+	let v = to_value(&12u32).unwrap();
+	assert_eq!(v, 12.into());
+
+	let v = to_value(& 42.0f64).unwrap();
+	assert_eq!(v, 42.0f64.into());
+
+	// strings
+	let v = to_value("hello").unwrap();
+	assert_eq!(v, "hello".into());
+
+	// arrays
+	let a = [1,2,3];
+	let v = to_value(&a).unwrap();
+	assert_eq!(v, a.iter().cloned().collect());
+
+	// maps
+	let m = {
+		use std::collections::BTreeMap;
+		let mut m = BTreeMap::new();
+		m.insert("17", 17);
+		m.insert("42", 42);
+		m
+	};
+	let v = to_value(&m).unwrap();
+	assert_eq!(v, Value::parse(r#"{ "17": 17, "42": 42 }"#).unwrap());
+}
+```
+
+With derived serialization:
+
+```rust
+# #![doc(test(no_crate_inject))]
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+
+extern crate sciter;
+extern crate sciter_serde;
+
+use sciter::Value;
+use sciter_serde::to_value;
+
+fn main() {
+
+	// structs
+	#[derive(Serialize)]
+	struct Test {
+		x: i32,
+		y: i32,
+	}
+
+	let v = to_value(&Test {x: 1, y: 2}).unwrap();
+	assert_eq!(v, Value::parse(r#"{ "x": 1, "y": 2 }"#).unwrap());
+}
+
+```
+
+*/
+#![allow(clippy::redundant_field_names)]
+#![allow(clippy::tabs_in_doc_comments)]
+
+#[macro_use]
+extern crate serde;
+extern crate sciter;
+
+
+mod error;
+mod ser;
+mod de;
+
+#[doc(inline)]
+pub use ser::to_value;
+
+#[doc(inline)]
+pub use de::from_value;
+
+pub use error::{Result, Error};

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))
+  }
+
+}