From c7d96b191edb7ea91fd7403e1c9df45a0c7a93cb Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 15 Jul 2016 16:24:26 +0200 Subject: [PATCH] next iteration --- serde-tests/Cargo.toml | 1 - serde-tests/build.rs | 6 +- src/encoder/serde.rs | 128 +++++++++++++++++++++++++++++++++++++---- 3 files changed, 119 insertions(+), 16 deletions(-) diff --git a/serde-tests/Cargo.toml b/serde-tests/Cargo.toml index 97d743a..aca29cb 100644 --- a/serde-tests/Cargo.toml +++ b/serde-tests/Cargo.toml @@ -9,7 +9,6 @@ serde = "0.7" toml = { path = "..", features = ["serde"] } [build-dependencies] -syntex = "0.33" serde_codegen = "0.7" [lib] diff --git a/serde-tests/build.rs b/serde-tests/build.rs index 7acbef5..1cc5062 100644 --- a/serde-tests/build.rs +++ b/serde-tests/build.rs @@ -1,4 +1,3 @@ -extern crate syntex; extern crate serde_codegen; use std::env; @@ -10,8 +9,5 @@ fn main() { let src = Path::new("test.rs.in"); let dst = Path::new(&out_dir).join("test.rs"); - let mut registry = syntex::Registry::new(); - - serde_codegen::register(&mut registry); - registry.expand("", &src, &dst).unwrap(); + serde_codegen::expand(&src, &dst).unwrap(); } diff --git a/src/encoder/serde.rs b/src/encoder/serde.rs index 49a6e2d..9c2f602 100644 --- a/src/encoder/serde.rs +++ b/src/encoder/serde.rs @@ -5,7 +5,12 @@ use super::{Encoder, Error, State}; impl ser::Serializer for Encoder { type Error = Error; type MapState = Self; + type StructState = Self; + type StructVariantState = Self; type SeqState = State; + type TupleState = State; + type TupleStructState = State; + type TupleVariantState = State; fn serialize_bool(&mut self, v: bool) -> Result<(), Error> { self.emit_value(Value::Boolean(v)) @@ -16,12 +21,42 @@ impl ser::Serializer for Encoder { fn serialize_u64(&mut self, v: u64) -> Result<(), Error> { self.serialize_i64(v as i64) } + fn serialize_isize(&mut self, v: isize) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_usize(&mut self, v: usize) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_i8(&mut self, v: i8) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_u8(&mut self, v: u8) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_i16(&mut self, v: i16) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_u16(&mut self, v: u16) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_i32(&mut self, v: i32) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_u32(&mut self, v: u32) -> Result<(), Error> { + self.serialize_i64(v as i64) + } + fn serialize_f32(&mut self, v: f32) -> Result<(), Error> { + self.serialize_f64(v as f64) + } fn serialize_f64(&mut self, v: f64) -> Result<(), Error> { self.emit_value(Value::Float(v)) } fn serialize_str(&mut self, value: &str) -> Result<(), Error> { self.emit_value(Value::String(value.to_string())) } + fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error> { + Ok(()) + } fn serialize_unit(&mut self) -> Result<(), Error> { Ok(()) } @@ -36,30 +71,95 @@ impl ser::Serializer for Encoder { { value.serialize(self) } + fn serialize_bytes(&mut self, v: &[u8]) -> Result<(), Error> { + let mut state = try!(self.serialize_seq(Some(v.len()))); + for c in v { + try!(self.serialize_seq_elt(&mut state, c)); + } + self.serialize_seq_end(state) + } + fn serialize_seq_fixed_size(&mut self, len: usize) -> Result { + self.serialize_seq(Some(len)) + } fn serialize_seq(&mut self, _len: Option) -> Result { self.seq_begin() } - fn serialize_seq_elt(&mut self, value: T) -> Result<(), Error> + fn serialize_seq_elt(&mut self, _state: &mut State, value: T) -> Result<(), Error> where T: ser::Serialize { value.serialize(self) } - fn serialize_seq_end(&mut self, _len: Option, state: State) -> Result<(), Error> { + fn serialize_seq_end(&mut self, state: State) -> Result<(), Error> { self.seq_end(state) } + fn serialize_tuple(&mut self, len: usize) -> Result { + self.serialize_seq(Some(len)) + } + fn serialize_tuple_elt(&mut self, state: &mut State, value: T) -> Result<(), Error> + where T: ser::Serialize + { + self.serialize_seq_elt(state, value) + } + fn serialize_tuple_end(&mut self, state: State) -> Result<(), Error> { + self.serialize_seq_end(state) + } + fn serialize_tuple_struct(&mut self, _name: &'static str, len: usize) -> Result { + self.serialize_seq(Some(len)) + } + fn serialize_tuple_struct_elt(&mut self, state: &mut State, value: T) -> Result<(), Error> + where T: ser::Serialize + { + self.serialize_seq_elt(state, value) + } + fn serialize_tuple_struct_end(&mut self, state: State) -> Result<(), Error> { + self.serialize_seq_end(state) + } + fn serialize_tuple_variant(&mut self, _name: &'static str, _id: usize, _variant: &'static str, len: usize) -> Result { + self.serialize_seq(Some(len)) + } + fn serialize_tuple_variant_elt(&mut self, state: &mut State, value: T) -> Result<(), Error> + where T: ser::Serialize + { + self.serialize_seq_elt(state, value) + } + fn serialize_tuple_variant_end(&mut self, state: State) -> Result<(), Error> { + self.serialize_seq_end(state) + } fn serialize_map(&mut self, _len: Option) -> Result { self.table_begin() } - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Error> + fn serialize_map_elt(&mut self, _state: &mut Encoder, key: K, value: V) -> Result<(), Error> where K: ser::Serialize, V: ser::Serialize { try!(self.table_key(|me| key.serialize(me))); try!(value.serialize(self)); Ok(()) } - fn serialize_map_end(&mut self, _len: Option, state: Self) -> Result<(), Error> { + fn serialize_map_end(&mut self, state: Self) -> Result<(), Error> { self.table_end(state) } + fn serialize_struct(&mut self, _name: &'static str, len: usize) -> Result { + self.serialize_map(Some(len)) + } + fn serialize_struct_elt(&mut self, state: &mut Encoder, key: &'static str, value: V) -> Result<(), Error> + where V: ser::Serialize + { + self.serialize_map_elt(state, key, value) + } + fn serialize_struct_end(&mut self, state: Self) -> Result<(), Error> { + self.serialize_map_end(state) + } + fn serialize_struct_variant(&mut self, _name: &'static str, _id: usize, _variant: &'static str, len: usize) -> Result { + self.serialize_map(Some(len)) + } + fn serialize_struct_variant_elt(&mut self, state: &mut Encoder, key: &'static str, value: V) -> Result<(), Error> + where V: ser::Serialize + { + self.serialize_map_elt(state, key, value) + } + fn serialize_struct_variant_end(&mut self, state: Self) -> Result<(), Error> { + self.serialize_map_end(state) + } fn serialize_newtype_struct(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error> @@ -78,6 +178,14 @@ impl ser::Serializer for Encoder { // Don't serialize the newtype struct variant in a tuple. value.serialize(self) } + fn serialize_unit_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + ) -> Result<(), Self::Error> + { + Ok(()) + } } impl ser::Serialize for Value { @@ -91,18 +199,18 @@ impl ser::Serialize for Value { Value::Boolean(b) => e.serialize_bool(b), Value::Datetime(ref s) => e.serialize_str(s), Value::Array(ref a) => { - let state = try!(e.serialize_seq(Some(a.len()))); + let mut state = try!(e.serialize_seq(Some(a.len()))); for el in a.iter() { - try!(e.serialize_seq_elt(el)); + try!(e.serialize_seq_elt(&mut state, el)); } - e.serialize_seq_end(Some(a.len()), state) + e.serialize_seq_end(state) } Value::Table(ref t) => { - let state = try!(e.serialize_map(Some(t.len()))); + let mut state = try!(e.serialize_map(Some(t.len()))); for (k, v) in t.iter() { - try!(e.serialize_map_elt(k, v)); + try!(e.serialize_map_elt(&mut state, k, v)); } - e.serialize_map_end(Some(t.len()), state) + e.serialize_map_end(state) } } }