NationTech/yaserde
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update code format

Browse Source
This commit is contained in:
Marc-Antoine Arnaud 2018-05-23 17:14:53 +02:00
parent 8b3d98d911
commit d63e9d27d8
18 changed files with 1218 additions and 970 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
yaserde/src/de/mod.rs
View File

@ -1,4 +1,3 @@
use std::io::Read;
use xml::reader::{EventReader, ParserConfig, XmlEvent};
use xml::name::OwnedName;
@ -56,9 +55,9 @@ impl<'de, R: Read> Deserializer<R> {
loop {
if let Ok(next) = self.reader.next() {
match next {
XmlEvent::StartDocument { .. } |
XmlEvent::ProcessingInstruction { .. } |
XmlEvent::Comment(_) => { /* skip */ },
XmlEvent::StartDocument { .. }
| XmlEvent::ProcessingInstruction { .. }
| XmlEvent::Comment(_) => { /* skip */ }
other => return Ok(other),
}
} else {
@ -77,11 +76,11 @@ impl<'de, R: Read> Deserializer<R> {
match next {
XmlEvent::StartElement { .. } => {
self.depth += 1;
},
}
XmlEvent::EndElement { .. } => {
self.depth -= 1;
},
_ => {},
}
_ => {}
}
debug!("Fetched {:?}", next);
Ok(next)
@ -113,14 +112,13 @@ impl<'de, R: Read> Deserializer<R> {
}
pub fn expect_end_element(&mut self, start_name: OwnedName) -> Result<(), String> {
if let XmlEvent::EndElement{ name, .. } = self.next()? {
if let XmlEvent::EndElement { name, .. } = self.next()? {
if name == start_name {
Ok(())
} else {
Err(format!(
"End tag </{}> didn't match the start tag <{}>",
name.local_name,
start_name.local_name
name.local_name, start_name.local_name
))
}
} else {

38
yaserde/src/lib.rs
View File

@ -1,4 +1,3 @@
#[macro_use]
extern crate log;
extern crate xml;
@ -13,11 +12,11 @@ use xml::writer::XmlEvent;
pub mod de;
pub mod ser;
pub trait YaDeserialize : Sized {
pub trait YaDeserialize: Sized {
fn deserialize<R: Read>(reader: &mut de::Deserializer<R>) -> Result<Self, String>;
}
pub trait YaSerialize : Sized {
pub trait YaSerialize: Sized {
fn serialize<W: Write>(&self, writer: &mut ser::Serializer<W>) -> Result<(), String>;
}
@ -25,60 +24,49 @@ pub trait Visitor<'de>: Sized {
/// The value produced by this visitor.
type Value;
fn visit_bool(self, v: &str) -> Result<Self::Value, String>
{
fn visit_bool(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected bool {}", v))
}
fn visit_i8(self, v: &str) -> Result<Self::Value, String>
{
fn visit_i8(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected i8 {}", v))
}
fn visit_u8(self, v: &str) -> Result<Self::Value, String>
{
fn visit_u8(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected u8 {}", v))
}
fn visit_i16(self, v: &str) -> Result<Self::Value, String>
{
fn visit_i16(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected i16 {}", v))
}
fn visit_u16(self, v: &str) -> Result<Self::Value, String>
{
fn visit_u16(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected u16 {}", v))
}
fn visit_i32(self, v: &str) -> Result<Self::Value, String>
{
fn visit_i32(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected i32 {}", v))
}
fn visit_u32(self, v: &str) -> Result<Self::Value, String>
{
fn visit_u32(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected u32 {}", v))
}
fn visit_i64(self, v: &str) -> Result<Self::Value, String>
{
fn visit_i64(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected i64 {}", v))
}
fn visit_u64(self, v: &str) -> Result<Self::Value, String>
{
fn visit_u64(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected u64 {}", v))
}
fn visit_str(self, v: &str) -> Result<Self::Value, String>
{
fn visit_str(self, v: &str) -> Result<Self::Value, String> {
Err(format!("Unexpected str {}", v))
}
#[inline]
#[cfg(any(feature = "std", feature = "alloc"))]
fn visit_string<String>(self, v: String) -> Result<Self::Value, String>
{
fn visit_string<String>(self, v: String) -> Result<Self::Value, String> {
self.visit_str(&v)
}
}

20
yaserde/src/ser/mod.rs
View File

@ -1,4 +1,3 @@
use std::str;
use std::io::{Cursor, Write};
use xml::{EmitterConfig, EventWriter};
@ -28,7 +27,10 @@ pub fn to_string_content<T: YaSerialize>(model: &T) -> Result<String, String> {
Ok(String::from(data))
}
pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(model: &T, writer: W) -> Result<W, String> {
pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(
model: &T,
writer: W,
) -> Result<W, String> {
let mut serializer = Serializer::new_for_inner(writer);
serializer.set_skip_start_end(true);
match model.serialize(&mut serializer) {
@ -39,27 +41,25 @@ pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(model: &T, writer
pub struct Serializer<W: Write> {
writer: EventWriter<W>,
skip_start_end: bool
skip_start_end: bool,
}
impl<'de, W: Write> Serializer<W> {
pub fn new(writer: EventWriter<W>) -> Self {
Serializer {
writer: writer,
skip_start_end: false
skip_start_end: false,
}
}
pub fn new_from_writer(writer: W) -> Self {
let config = EmitterConfig::new()
.cdata_to_characters(true);
let config = EmitterConfig::new().cdata_to_characters(true);
Self::new(EventWriter::new_with_config(writer, config))
}
pub fn new_for_inner(writer: W) -> Self {
let config = EmitterConfig::new()
.write_document_declaration(false);
let config = EmitterConfig::new().write_document_declaration(false);
Self::new(EventWriter::new_with_config(writer, config))
}
@ -77,7 +77,9 @@ impl<'de, W: Write> Serializer<W> {
}
pub fn write<'a, E>(&mut self, event: E) -> xml::writer::Result<()>
where E: Into<XmlEvent<'a>> {
where
E: Into<XmlEvent<'a>>,
{
self.writer.write(event)
}
}

34
yaserde/tests/der_namespace.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Read;
use yaserde::YaDeserialize;
@ -20,32 +19,33 @@ macro_rules! convert_and_validate {
#[test]
fn de_struct_namespace() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="book", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
#[yaserde(root = "book", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
pub struct Book {
#[yaserde(prefix="ns")]
author: String,
#[yaserde(prefix="ns")]
title: String,
#[yaserde(prefix = "ns")] author: String,
#[yaserde(prefix = "ns")] title: String,
}
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:book xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:author>Antoine de Saint-Exupéry</ns:author><ns:title>Little prince</ns:title></ns:book>";
convert_and_validate!(content, Book, Book{
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince")
});
convert_and_validate!(
content,
Book,
Book {
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince"),
}
);
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:book xmlns:ns=\"http://www.sample.com/ns/domain2\"><ns:author>Antoine de Saint-Exupéry</ns:author><ns:title>Little prince</ns:title></ns:book>";
let loaded : Result<Book, String> = from_str(content);
let loaded: Result<Book, String> = from_str(content);
assert_eq!(loaded, Err("bad namespace".to_string()));
}
#[test]
fn de_enum_namespace() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
#[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
pub enum XmlStruct {
#[yaserde(prefix="ns")]
Item
#[yaserde(prefix = "ns")] Item,
}
impl Default for XmlStruct {

7
yaserde/tests/der_type.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Read;
use yaserde::YaDeserialize;

238
yaserde/tests/deserializer.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Read;
use yaserde::YaDeserialize;
@ -20,188 +19,203 @@ macro_rules! convert_and_validate {
#[test]
fn de_basic() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="book")]
#[yaserde(root = "book")]
pub struct Book {
author: String,
title: String,
}
let content = "<book><author>Antoine de Saint-Exupéry</author><title>Little prince</title></book>";
convert_and_validate!(content, Book, Book{
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince")
});
let content =
"<book><author>Antoine de Saint-Exupéry</author><title>Little prince</title></book>";
convert_and_validate!(
content,
Book,
Book {
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince"),
}
);
let content = "<book><title>Little prince</title><author>Antoine de Saint-Exupéry</author></book>";
convert_and_validate!(content, Book, Book{
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince")
});
let content =
"<book><title>Little prince</title><author>Antoine de Saint-Exupéry</author></book>";
convert_and_validate!(
content,
Book,
Book {
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince"),
}
);
}
#[test]
fn de_list_of_items() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="library")]
#[yaserde(root = "library")]
pub struct Library {
books: Vec<String>
books: Vec<String>,
}
let content = "<library><books>Little Prince</books><books>Harry Potter</books></library>";
convert_and_validate!(content, Library, Library{
books: vec![
String::from("Little Prince"),
String::from("Harry Potter")
]
});
convert_and_validate!(
content,
Library,
Library {
books: vec![String::from("Little Prince"), String::from("Harry Potter")],
}
);
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="libraries")]
#[yaserde(root = "libraries")]
pub struct Libraries {
library: Vec<Library>
library: Vec<Library>,
}
let content = "<libraries><library><books>Little Prince</books></library><library><books>Harry Potter</books></library></libraries>";
convert_and_validate!(content, Libraries, Libraries{
library: vec![
Library{
books: vec![
String::from("Little Prince")
]
},
Library{
books: vec![
String::from("Harry Potter")
]
}
]
});
convert_and_validate!(
content,
Libraries,
Libraries {
library: vec![
Library {
books: vec![String::from("Little Prince")],
},
Library {
books: vec![String::from("Harry Potter")],
},
],
}
);
}
#[test]
fn de_attributes() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute)]
item: String,
sub: SubStruct
#[yaserde(attribute)] item: String,
sub: SubStruct,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute)]
subitem: String
#[yaserde(attribute)] subitem: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
subitem: "".to_string()
SubStruct {
subitem: "".to_string(),
}
}
}
let content = "<base item=\"something\"><sub subitem=\"sub-something\"></sub></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
item: "something".to_string(),
sub: SubStruct{
subitem: "sub-something".to_string()
convert_and_validate!(
content,
XmlStruct,
XmlStruct {
item: "something".to_string(),
sub: SubStruct {
subitem: "sub-something".to_string(),
},
}
});
);
}
#[test]
fn de_rename() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute, rename="Item")]
item: String,
#[yaserde(rename="sub")]
sub_struct: SubStruct
#[yaserde(attribute, rename = "Item")] item: String,
#[yaserde(rename = "sub")] sub_struct: SubStruct,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute, rename="sub_item")]
subitem: String,
#[yaserde(attribute, rename = "sub_item")] subitem: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
subitem: "".to_string()
SubStruct {
subitem: "".to_string(),
}
}
}
let content = "<base Item=\"something\"><sub sub_item=\"sub_something\"></sub></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
item: "something".to_string(),
sub_struct: SubStruct{
subitem: "sub_something".to_string()
convert_and_validate!(
content,
XmlStruct,
XmlStruct {
item: "something".to_string(),
sub_struct: SubStruct {
subitem: "sub_something".to_string(),
},
}
});
);
}
#[test]
fn de_text_content_with_attributes() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute, rename="Item")]
item: String,
#[yaserde(rename="sub")]
sub_struct: SubStruct
#[yaserde(attribute, rename = "Item")] item: String,
#[yaserde(rename = "sub")] sub_struct: SubStruct,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute, rename="sub_item")]
subitem: String,
#[yaserde(text)]
text: String
#[yaserde(attribute, rename = "sub_item")] subitem: String,
#[yaserde(text)] text: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
SubStruct {
subitem: "".to_string(),
text: "".to_string(),
}
}
}
let content = "<base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
item: "something".to_string(),
sub_struct: SubStruct{
subitem: "sub_something".to_string(),
text: "text_content".to_string()
let content =
"<base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
convert_and_validate!(
content,
XmlStruct,
XmlStruct {
item: "something".to_string(),
sub_struct: SubStruct {
subitem: "sub_something".to_string(),
text: "text_content".to_string(),
},
}
});
);
}
#[test]
fn de_enum() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
background: Color
background: Color,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct Colors {
items: Vec<Color>
items: Vec<Color>,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="color")]
#[yaserde(root = "color")]
pub enum Color {
White,
Black,
@ -222,7 +236,7 @@ fn de_enum() {
impl Default for RGBColor {
fn default() -> RGBColor {
RGBColor{
RGBColor {
red: "0".to_string(),
green: "0".to_string(),
blue: "0".to_string(),
@ -230,28 +244,36 @@ fn de_enum() {
}
}
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
background: Color::Black
});
let content =
"<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
convert_and_validate!(
content,
XmlStruct,
XmlStruct {
background: Color::Black,
}
);
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>Black</items><items>White</items></base>";
convert_and_validate!(content, Colors, Colors{
items: vec![Color::Black, Color::White]
});
convert_and_validate!(
content,
Colors,
Colors {
items: vec![Color::Black, Color::White],
}
);
}
#[test]
fn de_attribute_enum() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute)]
background: Color
#[yaserde(attribute)] background: Color,
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="color")]
#[yaserde(root = "color")]
pub enum Color {
White,
Black,
@ -264,7 +286,11 @@ fn de_attribute_enum() {
}
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base background=\"Black\" />";
convert_and_validate!(content, XmlStruct, XmlStruct{
background: Color::Black
});
convert_and_validate!(
content,
XmlStruct,
XmlStruct {
background: Color::Black,
}
);
}

55
yaserde/tests/se_namespace.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Write;
use yaserde::YaSerialize;
@ -20,14 +19,13 @@ macro_rules! convert_and_validate {
#[test]
fn ser_struct_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
#[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
pub struct XmlStruct {
#[yaserde(prefix="ns")]
item: String
#[yaserde(prefix = "ns")] item: String,
}
let model = XmlStruct {
item: "something".to_string()
item: "something".to_string(),
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:root xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:item>something</ns:item></ns:root>";
@ -37,10 +35,9 @@ fn ser_struct_namespace() {
#[test]
fn ser_enum_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
#[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
pub enum XmlStruct {
#[yaserde(prefix="ns")]
Item
#[yaserde(prefix = "ns")] Item,
}
let model = XmlStruct::Item;
@ -52,12 +49,11 @@ fn ser_enum_namespace() {
#[test]
fn ser_struct_multi_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
#[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
namespace = "ns2: http://www.sample.com/ns/domain2")]
pub struct XmlStruct {
#[yaserde(prefix="ns1")]
item_1: String,
#[yaserde(prefix="ns2")]
item_2: String,
#[yaserde(prefix = "ns1")] item_1: String,
#[yaserde(prefix = "ns2")] item_2: String,
}
let model = XmlStruct {
@ -69,16 +65,14 @@ fn ser_struct_multi_namespace() {
convert_and_validate!(model, content);
}
#[test]
fn ser_enum_multi_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
#[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
namespace = "ns2: http://www.sample.com/ns/domain2")]
pub enum XmlStruct {
#[yaserde(prefix="ns1")]
Item1,
#[yaserde(prefix="ns2")]
Item2,
#[yaserde(prefix = "ns1")] Item1,
#[yaserde(prefix = "ns2")] Item2,
}
let model1 = XmlStruct::Item1;
@ -89,16 +83,14 @@ fn ser_enum_multi_namespace() {
convert_and_validate!(model2, content);
}
#[test]
fn ser_struct_attribute_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
#[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
namespace = "ns2: http://www.sample.com/ns/domain2")]
pub struct XmlStruct {
#[yaserde(prefix="ns1")]
item_1: String,
#[yaserde(attribute, prefix="ns2")]
item_2: String,
#[yaserde(prefix = "ns1")] item_1: String,
#[yaserde(attribute, prefix = "ns2")] item_2: String,
}
let model = XmlStruct {
@ -113,13 +105,14 @@ fn ser_struct_attribute_namespace() {
#[test]
fn ser_struct_default_namespace() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="tt", namespace="http://www.w3.org/ns/ttml", namespace="ttm: http://www.w3.org/ns/ttml#metadata")]
#[yaserde(root = "tt", namespace = "http://www.w3.org/ns/ttml",
namespace = "ttm: http://www.w3.org/ns/ttml#metadata")]
pub struct XmlStruct {
item: String
item: String,
}
let model = XmlStruct {
item: "something".to_string()
item: "something".to_string(),
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\"><item>something</item></tt>";

7
yaserde/tests/se_type.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Write;
use yaserde::YaSerialize;

162
yaserde/tests/serializer.rs
View File

@ -1,10 +1,9 @@
#[macro_use]
extern crate log;
extern crate xml;
extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Write;
use yaserde::YaSerialize;
@ -20,13 +19,13 @@ macro_rules! convert_and_validate {
#[test]
fn ser_basic() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
item: String
item: String,
}
let model = XmlStruct {
item: "something".to_string()
item: "something".to_string(),
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><item>something</item></base>";
@ -36,44 +35,39 @@ fn ser_basic() {
#[test]
fn ser_list_of_items() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
items: Vec<String>
items: Vec<String>,
}
let model = XmlStruct{
items: vec![
"something1".to_string(),
"something2".to_string()
]
let model = XmlStruct {
items: vec!["something1".to_string(), "something2".to_string()],
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>something1</items><items>something2</items></base>";
convert_and_validate!(model, content);
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStructOfStruct {
items: Vec<SubStruct>
items: Vec<SubStruct>,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="items")]
#[yaserde(root = "items")]
pub struct SubStruct {
field: String
field: String,
}
let model2 = XmlStructOfStruct{
let model2 = XmlStructOfStruct {
items: vec![
SubStruct{
field: "something1".to_string()
SubStruct {
field: "something1".to_string(),
},
SubStruct{
field: "something2".to_string()
}
]
SubStruct {
field: "something2".to_string(),
},
],
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items><field>something1</field></items><items><field>something2</field></items></base>";
@ -83,33 +77,31 @@ fn ser_list_of_items() {
#[test]
fn se_attributes() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute)]
item: String,
sub: SubStruct
#[yaserde(attribute)] item: String,
sub: SubStruct,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute)]
subitem: String
#[yaserde(attribute)] subitem: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
subitem: "".to_string()
SubStruct {
subitem: "".to_string(),
}
}
}
let model = XmlStruct{
let model = XmlStruct {
item: "something".to_string(),
sub: SubStruct{
subitem: "sub-something".to_string()
}
sub: SubStruct {
subitem: "sub-something".to_string(),
},
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base item=\"something\"><sub subitem=\"sub-something\" /></base>";
@ -119,34 +111,31 @@ fn se_attributes() {
#[test]
fn ser_rename() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute, rename="Item")]
item: String,
#[yaserde(rename="sub")]
sub_struct: SubStruct
#[yaserde(attribute, rename = "Item")] item: String,
#[yaserde(rename = "sub")] sub_struct: SubStruct,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute, rename="sub_item")]
subitem: String,
#[yaserde(attribute, rename = "sub_item")] subitem: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
subitem: "".to_string()
SubStruct {
subitem: "".to_string(),
}
}
}
let model = XmlStruct{
let model = XmlStruct {
item: "something".to_string(),
sub_struct: SubStruct{
subitem: "sub_something".to_string()
}
sub_struct: SubStruct {
subitem: "sub_something".to_string(),
},
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\" /></base>";
@ -156,38 +145,34 @@ fn ser_rename() {
#[test]
fn ser_text_content_with_attributes() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute, rename="Item")]
item: String,
#[yaserde(rename="sub")]
sub_struct: SubStruct
#[yaserde(attribute, rename = "Item")] item: String,
#[yaserde(rename = "sub")] sub_struct: SubStruct,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="sub")]
#[yaserde(root = "sub")]
pub struct SubStruct {
#[yaserde(attribute, rename="sub_item")]
subitem: String,
#[yaserde(text)]
text: String,
#[yaserde(attribute, rename = "sub_item")] subitem: String,
#[yaserde(text)] text: String,
}
impl Default for SubStruct {
fn default() -> SubStruct {
SubStruct{
SubStruct {
subitem: "".to_string(),
text: "".to_string(),
}
}
}
let model = XmlStruct{
let model = XmlStruct {
item: "something".to_string(),
sub_struct: SubStruct{
sub_struct: SubStruct {
subitem: "sub_something".to_string(),
text: "text_content".to_string()
}
text: "text_content".to_string(),
},
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
@ -197,23 +182,23 @@ fn ser_text_content_with_attributes() {
#[test]
fn ser_enum() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
color: Color
color: Color,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="color")]
#[yaserde(root = "color")]
pub enum Color {
White,
Black,
#[yaserde(rename="custom")]
#[yaserde(rename = "custom")]
Custom {
enabled: String,
color: RGBColor,
alpha: Alpha,
alphas: Vec<Alpha>,
}
},
}
impl Default for Color {
@ -235,50 +220,45 @@ fn ser_enum() {
Opaque,
}
let model = XmlStruct{
color: Color::Black
let model = XmlStruct {
color: Color::Black,
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><color>Black</color></base>";
convert_and_validate!(model, content);
let model = XmlStruct{
color: Color::Custom{
let model = XmlStruct {
color: Color::Custom {
enabled: "true".to_string(),
color: RGBColor{
color: RGBColor {
red: "0".to_string(),
green: "128".to_string(),
blue: "255".to_string(),
},
alpha: Alpha::Opaque,
alphas: vec![Alpha::Opaque, Alpha::Transparent]
}
alphas: vec![Alpha::Opaque, Alpha::Transparent],
},
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><color><custom><enabled>true</enabled><color><red>0</red><green>128</green><blue>255</blue></color><alpha>Opaque</alpha><alphas>Opaque</alphas><alphas>Transparent</alphas></custom></color></base>";
convert_and_validate!(model, content);
}
#[test]
fn ser_attribute_enum() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
#[yaserde(root = "base")]
pub struct XmlStruct {
#[yaserde(attribute)]
color: Color
#[yaserde(attribute)] color: Color,
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="color")]
#[yaserde(root = "color")]
pub enum Color {
#[yaserde(rename="pink")]
Pink,
#[yaserde(rename = "pink")] Pink,
}
let model = XmlStruct{
color: Color::Pink
};
let model = XmlStruct { color: Color::Pink };
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base color=\"pink\" />";
convert_and_validate!(model, content);

85
yaserde_derive/src/attribute.rs
View File

@ -1,4 +1,3 @@
use proc_macro2::TokenTreeIter;
use proc_macro2::TokenNode::*;
use proc_macro2::Spacing;
@ -18,13 +17,9 @@ pub struct YaSerdeAttribute {
fn get_value(iter: &mut TokenTreeIter) -> Option<String> {
match (iter.next(), iter.next()) {
(Some(operator), Some(value)) => {
match (operator.kind, value.kind) {
(Op('=', Spacing::Alone), Literal(l)) => {
Some(l.to_string().replace("\"", ""))
},
_ => None,
}
(Some(operator), Some(value)) => match (operator.kind, value.kind) {
(Op('=', Spacing::Alone), Literal(l)) => Some(l.to_string().replace("\"", "")),
_ => None,
},
_ => None,
}
@ -42,54 +37,48 @@ impl YaSerdeAttribute {
for attr in attrs.iter() {
let mut attr_iter = attr.clone().tts.into_iter();
match attr_iter.next() {
Some(token) => {
match token.kind {
Group(Parenthesis, token_stream) => {
let mut attr_iter = token_stream.into_iter();
Some(token) => match token.kind {
Group(Parenthesis, token_stream) => {
let mut attr_iter = token_stream.into_iter();
while let Some(item) = attr_iter.next() {
match item.kind {
Term(t) => {
match t.as_str() {
"attribute" => {
attribute = true;
},
"namespace" => {
if let Some(namespace) = get_value(&mut attr_iter) {
let splitted : Vec<&str> = namespace.split(": ").collect();
if splitted.len() == 2 {
namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned());
}
if splitted.len() == 1 {
namespaces.insert("".to_owned(), splitted[0].to_owned());
}
}
},
"prefix" => {
prefix = get_value(&mut attr_iter);
while let Some(item) = attr_iter.next() {
match item.kind {
Term(t) => match t.as_str() {
"attribute" => {
attribute = true;
}
"namespace" => {
if let Some(namespace) = get_value(&mut attr_iter) {
let splitted: Vec<&str> = namespace.split(": ").collect();
if splitted.len() == 2 {
namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned());
}
"rename" => {
rename = get_value(&mut attr_iter);
},
"root" => {
root = get_value(&mut attr_iter);
},
"text" => {
text = true;
if splitted.len() == 1 {
namespaces.insert("".to_owned(), splitted[0].to_owned());
}
_ => {},
}
},
}
"prefix" => {
prefix = get_value(&mut attr_iter);
}
"rename" => {
rename = get_value(&mut attr_iter);
}
"root" => {
root = get_value(&mut attr_iter);
}
"text" => {
text = true;
}
_ => {}
}
},
_ => {}
}
},
_ => {},
}
}
_ => {}
},
None => {},
None => {}
}
}

288
yaserde_derive/src/de/expand_enum.rs
View File

@ -1,4 +1,3 @@
use attribute::*;
use field_type::*;
use quote::Tokens;
@ -8,125 +7,167 @@ use syn::Ident;
use syn::DataEnum;
use proc_macro2::Span;
pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BTreeMap<String, String>) -> Tokens {
let variables : Tokens = data_enum.variants.iter().map(|ref variant|
{
match variant.fields {
Fields::Unit => None,
Fields::Named(ref fields) => {
let enum_fields = fields.named.iter().map(|ref field| {
pub fn parse(
data_enum: &DataEnum,
name: &Ident,
root: &String,
_namespaces: &BTreeMap<String, String>,
) -> Tokens {
let variables: Tokens = data_enum
.variants
.iter()
.map(|ref variant| match variant.fields {
Fields::Unit => None,
Fields::Named(ref fields) => {
let enum_fields = fields
.named
.iter()
.map(|ref field| {
let field_label = field.ident;
match get_field_type(field) {
Some(FieldType::FieldTypeString) =>
build_default_value(&field_label, quote!{String}, quote!{"".to_string()}),
Some(FieldType::FieldTypeBool) =>
build_default_value(&field_label, quote!{bool}, quote!{false}),
Some(FieldType::FieldTypeI8) =>
build_default_value(&field_label, quote!{i8}, quote!{0}),
Some(FieldType::FieldTypeU8) =>
build_default_value(&field_label, quote!{u8}, quote!{0}),
Some(FieldType::FieldTypeI16) =>
build_default_value(&field_label, quote!{i16}, quote!{0}),
Some(FieldType::FieldTypeU16) =>
build_default_value(&field_label, quote!{u16}, quote!{0}),
Some(FieldType::FieldTypeI32) =>
build_default_value(&field_label, quote!{i32}, quote!{0}),
Some(FieldType::FieldTypeU32) =>
build_default_value(&field_label, quote!{u32}, quote!{0}),
Some(FieldType::FieldTypeI64) =>
build_default_value(&field_label, quote!{i64}, quote!{0}),
Some(FieldType::FieldTypeU64) =>
build_default_value(&field_label, quote!{u64}, quote!{0}),
Some(FieldType::FieldTypeStruct{struct_name}) => {
Some(quote!{
#[allow(unused_mut)]
let mut #field_label : #struct_name = #struct_name::default();
})
},
Some(FieldType::FieldTypeVec{data_type}) => {
Some(FieldType::FieldTypeString) => {
build_default_value(&field_label, quote!{String}, quote!{"".to_string()})
}
Some(FieldType::FieldTypeBool) => {
build_default_value(&field_label, quote!{bool}, quote!{false})
}
Some(FieldType::FieldTypeI8) => {
build_default_value(&field_label, quote!{i8}, quote!{0})
}
Some(FieldType::FieldTypeU8) => {
build_default_value(&field_label, quote!{u8}, quote!{0})
}
Some(FieldType::FieldTypeI16) => {
build_default_value(&field_label, quote!{i16}, quote!{0})
}
Some(FieldType::FieldTypeU16) => {
build_default_value(&field_label, quote!{u16}, quote!{0})
}
Some(FieldType::FieldTypeI32) => {
build_default_value(&field_label, quote!{i32}, quote!{0})
}
Some(FieldType::FieldTypeU32) => {
build_default_value(&field_label, quote!{u32}, quote!{0})
}
Some(FieldType::FieldTypeI64) => {
build_default_value(&field_label, quote!{i64}, quote!{0})
}
Some(FieldType::FieldTypeU64) => {
build_default_value(&field_label, quote!{u64}, quote!{0})
}
Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
#[allow(unused_mut)]
let mut #field_label : #struct_name = #struct_name::default();
}),
Some(FieldType::FieldTypeVec { data_type }) => {
let dt = Box::into_raw(data_type);
match unsafe{dt.as_ref()} {
Some(&FieldType::FieldTypeString) =>
build_default_value(&field_label, quote!{Vec<String>}, quote!{vec![]}),
Some(&FieldType::FieldTypeBool) =>
build_default_value(&field_label, quote!{Vec<bool>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI8) =>
build_default_value(&field_label, quote!{Vec<i8>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU8) =>
build_default_value(&field_label, quote!{Vec<u8>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI16) =>
build_default_value(&field_label, quote!{Vec<i16>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU16) =>
build_default_value(&field_label, quote!{Vec<u16>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI32) =>
build_default_value(&field_label, quote!{Vec<i32>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU32) =>
build_default_value(&field_label, quote!{Vec<u32>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI64) =>
build_default_value(&field_label, quote!{Vec<i64>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU64) =>
build_default_value(&field_label, quote!{Vec<u64>}, quote!{vec![]}),
Some(&FieldType::FieldTypeStruct{struct_name}) => {
Some(quote!{
#[allow(unused_mut)]
let mut #field_label : Vec<#struct_name> = vec![];
})
},
Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
None => {unimplemented!();},
match unsafe { dt.as_ref() } {
Some(&FieldType::FieldTypeString) => {
build_default_value(&field_label, quote!{Vec<String>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeBool) => {
build_default_value(&field_label, quote!{Vec<bool>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI8) => {
build_default_value(&field_label, quote!{Vec<i8>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU8) => {
build_default_value(&field_label, quote!{Vec<u8>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI16) => {
build_default_value(&field_label, quote!{Vec<i16>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU16) => {
build_default_value(&field_label, quote!{Vec<u16>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI32) => {
build_default_value(&field_label, quote!{Vec<i32>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU32) => {
build_default_value(&field_label, quote!{Vec<u32>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI64) => {
build_default_value(&field_label, quote!{Vec<i64>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU64) => {
build_default_value(&field_label, quote!{Vec<u64>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
#[allow(unused_mut)]
let mut #field_label : Vec<#struct_name> = vec![];
}),
Some(&FieldType::FieldTypeVec { .. }) => {
unimplemented!();
}
None => {
unimplemented!();
}
}
},
None => None
}
None => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
Some(enum_fields)
}
Fields::Unnamed(ref _fields) => {
unimplemented!();
}
Some(enum_fields)
}
Fields::Unnamed(ref _fields) => {
unimplemented!();
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let enum_visitors: Tokens = data_enum.variants.iter().map(|ref variant| {
let enum_visitors: Tokens = data_enum
.variants
.iter()
.map(|ref variant| {
match variant.fields {
Fields::Unit => None,
Fields::Named(ref fields) => {
let enum_fields = fields.named.iter().map(|ref field| {
// let label = field.ident;
// let label_name = label.unwrap().to_string();
// let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
let enum_fields = fields
.named
.iter()
.map(|ref field| {
// let label = field.ident;
// let label_name = label.unwrap().to_string();
// let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
match get_field_type(field) {
Some(FieldType::FieldTypeString) => {
Some(quote!{
// struct #visitor_label;
// impl<'de> Visitor<'de> for #visitor_label {
// type Value = String;
match get_field_type(field) {
Some(FieldType::FieldTypeString) => {
Some(quote!{
// struct #visitor_label;
// impl<'de> Visitor<'de> for #visitor_label {
// type Value = String;
// fn visit_str(self, v: &str) -> Result<Self::Value, String> {
// match v {
// _ => Err("unable to match \"{}\" with enum {}", v, #label_name)
// }
// Ok(String::from(v))
// }
// }
})
},
_ => None
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
// fn visit_str(self, v: &str) -> Result<Self::Value, String> {
// match v {
// _ => Err("unable to match \"{}\" with enum {}", v, #label_name)
// }
// Ok(String::from(v))
// }
// }
})
}
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
Some(enum_fields)
}
@ -137,35 +178,38 @@ pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BT
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let match_to_enum : Tokens = data_enum.variants.iter().map(|ref variant|
{
let match_to_enum: Tokens = data_enum
.variants
.iter()
.map(|ref variant| {
let field_attrs = YaSerdeAttribute::parse(&variant.attrs);
let renamed_label =
match field_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident
};
let renamed_label = match field_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident,
};
let label = variant.ident;
let label_name = renamed_label.to_string();
match variant.fields {
Fields::Unit => {
Some(quote!{
#label_name => {
simple_enum_value = Some(#name::#label);
}
})
},
_ => {
None
}
Fields::Unit => Some(quote!{
#label_name => {
simple_enum_value = Some(#name::#label);
}
}),
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
quote!{
use xml::reader::XmlEvent;
@ -228,7 +272,11 @@ pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BT
}
}
fn build_default_value(label: &Option<Ident>, field_type: Tokens, default: Tokens) -> Option<Tokens> {
fn build_default_value(
label: &Option<Ident>,
field_type: Tokens,
default: Tokens,
) -> Option<Tokens> {
Some(quote!{
#[allow(unused_mut)]
let mut #label : #field_type = #default;

680
yaserde_derive/src/de/expand_struct.rs
View File

@ -1,4 +1,3 @@
use attribute::*;
use field_type::*;
use quote::Tokens;
@ -7,9 +6,15 @@ use syn::Ident;
use syn::DataStruct;
use proc_macro2::Span;
pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
let validate_namespace : Tokens = namespaces.iter().map(|(ref _prefix, ref namespace)| {
pub fn parse(
data_struct: &DataStruct,
name: &Ident,
root: &String,
namespaces: &BTreeMap<String, String>,
) -> Tokens {
let validate_namespace: Tokens = namespaces
.iter()
.map(|(ref _prefix, ref namespace)| {
Some(quote!(
let mut found = false;
@ -26,88 +31,98 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
let variables: Tokens = data_struct.fields.iter().map(|ref field|
{
let variables: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let label = field.ident;
match get_field_type(field) {
Some(FieldType::FieldTypeString) =>
build_default_value(&label, quote!{String}, quote!{"".to_string()}),
Some(FieldType::FieldTypeBool) =>
build_default_value(&label, quote!{bool}, quote!{false}),
Some(FieldType::FieldTypeI8) =>
build_default_value(&label, quote!{i8}, quote!{0}),
Some(FieldType::FieldTypeU8) =>
build_default_value(&label, quote!{u8}, quote!{0}),
Some(FieldType::FieldTypeI16) =>
build_default_value(&label, quote!{i16}, quote!{0}),
Some(FieldType::FieldTypeU16) =>
build_default_value(&label, quote!{u16}, quote!{0}),
Some(FieldType::FieldTypeI32) =>
build_default_value(&label, quote!{i32}, quote!{0}),
Some(FieldType::FieldTypeU32) =>
build_default_value(&label, quote!{u32}, quote!{0}),
Some(FieldType::FieldTypeI64) =>
build_default_value(&label, quote!{i64}, quote!{0}),
Some(FieldType::FieldTypeU64) =>
build_default_value(&label, quote!{u64}, quote!{0}),
Some(FieldType::FieldTypeStruct{struct_name}) => {
Some(quote!{
#[allow(unused_mut, non_snake_case, non_camel_case_types)]
let mut #label : #struct_name = #struct_name::default();
})
},
Some(FieldType::FieldTypeVec{data_type}) => {
Some(FieldType::FieldTypeString) => {
build_default_value(&label, quote!{String}, quote!{"".to_string()})
}
Some(FieldType::FieldTypeBool) => build_default_value(&label, quote!{bool}, quote!{false}),
Some(FieldType::FieldTypeI8) => build_default_value(&label, quote!{i8}, quote!{0}),
Some(FieldType::FieldTypeU8) => build_default_value(&label, quote!{u8}, quote!{0}),
Some(FieldType::FieldTypeI16) => build_default_value(&label, quote!{i16}, quote!{0}),
Some(FieldType::FieldTypeU16) => build_default_value(&label, quote!{u16}, quote!{0}),
Some(FieldType::FieldTypeI32) => build_default_value(&label, quote!{i32}, quote!{0}),
Some(FieldType::FieldTypeU32) => build_default_value(&label, quote!{u32}, quote!{0}),
Some(FieldType::FieldTypeI64) => build_default_value(&label, quote!{i64}, quote!{0}),
Some(FieldType::FieldTypeU64) => build_default_value(&label, quote!{u64}, quote!{0}),
Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
#[allow(unused_mut, non_snake_case, non_camel_case_types)]
let mut #label : #struct_name = #struct_name::default();
}),
Some(FieldType::FieldTypeVec { data_type }) => {
let dt = Box::into_raw(data_type);
match unsafe{dt.as_ref()} {
Some(&FieldType::FieldTypeString) =>
build_default_value(&label, quote!{Vec<String>}, quote!{vec![]}),
Some(&FieldType::FieldTypeBool) =>
build_default_value(&label, quote!{Vec<bool>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI8) =>
build_default_value(&label, quote!{Vec<i8>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU8) =>
build_default_value(&label, quote!{Vec<u8>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI16) =>
build_default_value(&label, quote!{Vec<i16>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU16) =>
build_default_value(&label, quote!{Vec<u16>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI32) =>
build_default_value(&label, quote!{Vec<i32>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU32) =>
build_default_value(&label, quote!{Vec<u32>}, quote!{vec![]}),
Some(&FieldType::FieldTypeI64) =>
build_default_value(&label, quote!{Vec<i64>}, quote!{vec![]}),
Some(&FieldType::FieldTypeU64) =>
build_default_value(&label, quote!{Vec<u64>}, quote!{vec![]}),
Some(&FieldType::FieldTypeStruct{struct_name}) => {
Some(quote!{
#[allow(unused_mut)]
let mut #label : Vec<#struct_name> = vec![];
})
},
Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
None => {unimplemented!();},
match unsafe { dt.as_ref() } {
Some(&FieldType::FieldTypeString) => {
build_default_value(&label, quote!{Vec<String>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeBool) => {
build_default_value(&label, quote!{Vec<bool>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI8) => {
build_default_value(&label, quote!{Vec<i8>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU8) => {
build_default_value(&label, quote!{Vec<u8>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI16) => {
build_default_value(&label, quote!{Vec<i16>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU16) => {
build_default_value(&label, quote!{Vec<u16>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI32) => {
build_default_value(&label, quote!{Vec<i32>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU32) => {
build_default_value(&label, quote!{Vec<u32>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeI64) => {
build_default_value(&label, quote!{Vec<i64>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeU64) => {
build_default_value(&label, quote!{Vec<u64>}, quote!{vec![]})
}
Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
#[allow(unused_mut)]
let mut #label : Vec<#struct_name> = vec![];
}),
Some(&FieldType::FieldTypeVec { .. }) => {
unimplemented!();
}
None => {
unimplemented!();
}
}
},
_ => None
}
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let field_visitors: Tokens = data_struct.fields.iter().map(|ref field|
{
let field_visitors: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
let label_name =
if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else {
field.ident.unwrap().to_string()
};
let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else {
field.ident.unwrap().to_string()
};
let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
@ -115,46 +130,49 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
Some(FieldType::FieldTypeString) => {
let visitor = Ident::new("visit_str", Span::call_site());
build_declare_visitor(quote!{String}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeBool) => {
let visitor = Ident::new("visit_bool", Span::call_site());
build_declare_visitor(quote!{bool}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeI8) => {
let visitor = Ident::new("visit_i8", Span::call_site());
build_declare_visitor(quote!{i8}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeU8) => {
let visitor = Ident::new("visit_u8", Span::call_site());
build_declare_visitor(quote!{u8}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeI16) => {
let visitor = Ident::new("visit_i16", Span::call_site());
build_declare_visitor(quote!{i16}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeU16) => {
let visitor = Ident::new("visit_u16", Span::call_site());
build_declare_visitor(quote!{u16}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeI32) => {
let visitor = Ident::new("visit_i32", Span::call_site());
build_declare_visitor(quote!{i32}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeU32) => {
let visitor = Ident::new("visit_u32", Span::call_site());
build_declare_visitor(quote!{u32}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeI64) => {
let visitor = Ident::new("visit_i64", Span::call_site());
build_declare_visitor(quote!{i64}, &visitor, &visitor_label)
},
}
Some(FieldType::FieldTypeU64) => {
let visitor = Ident::new("visit_u64", Span::call_site());
build_declare_visitor(quote!{u64}, &visitor, &visitor_label)
},
Some(FieldType::FieldTypeStruct{struct_name}) => {
}
Some(FieldType::FieldTypeStruct { struct_name }) => {
let struct_id = struct_name.to_string();
let struct_ident = Ident::new(&format!("__Visitor_{}_{}", label_name, struct_name), Span::call_site());
let struct_ident = Ident::new(
&format!("__Visitor_{}_{}", label_name, struct_name),
Span::call_site(),
);
Some(quote!{
#[allow(non_snake_case, non_camel_case_types)]
@ -169,10 +187,10 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
}
}
})
},
Some(FieldType::FieldTypeVec{data_type}) => {
}
Some(FieldType::FieldTypeVec { data_type }) => {
let dt = Box::into_raw(data_type);
match unsafe{dt.as_ref()} {
match unsafe { dt.as_ref() } {
Some(&FieldType::FieldTypeString) => {
let visitor = Ident::new("visit_str", Span::call_site());
build_declare_visitor(quote!{String}, &visitor, &visitor_label)
@ -213,7 +231,7 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
let visitor = Ident::new("visit_u64", Span::call_site());
build_declare_visitor(quote!{u64}, &visitor, &visitor_label)
}
Some(&FieldType::FieldTypeStruct{struct_name}) => {
Some(&FieldType::FieldTypeStruct { struct_name }) => {
let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
Some(quote!{
#[allow(non_snake_case, non_camel_case_types)]
@ -223,20 +241,23 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
}
})
}
_ => {
None
}
_ => None,
}
},
_ => None
}
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let call_visitors: Tokens = data_struct.fields.iter().map(|ref field|
{
let call_visitors: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
let label = field.ident;
@ -244,116 +265,253 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
return None;
}
let label_name =
if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else {
field.ident.unwrap().to_string()
};
let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else {
field.ident.unwrap().to_string()
};
let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
match get_field_type(field) {
Some(FieldType::FieldTypeString) => {
let visitor = Ident::new("visit_str", Span::call_site());
build_call_visitor(quote!{String}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{String},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeBool) => {
let visitor = Ident::new("visit_bool", Span::call_site());
build_call_visitor(quote!{bool}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{bool},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeI8) => {
let visitor = Ident::new("visit_i8", Span::call_site());
build_call_visitor(quote!{i8}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{i8},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeU8) => {
let visitor = Ident::new("visit_u8", Span::call_site());
build_call_visitor(quote!{u8}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{u8},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeU16) => {
let visitor = Ident::new("visit_u16", Span::call_site());
build_call_visitor(quote!{u16}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{u16},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeI16) => {
let visitor = Ident::new("visit_i16", Span::call_site());
build_call_visitor(quote!{i16}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{i16},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeU32) => {
let visitor = Ident::new("visit_u32", Span::call_site());
build_call_visitor(quote!{u32}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{u32},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeI32) => {
let visitor = Ident::new("visit_i32", Span::call_site());
build_call_visitor(quote!{i32}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{i32},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeU64) => {
let visitor = Ident::new("visit_u64", Span::call_site());
build_call_visitor(quote!{u64}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
build_call_visitor(
quote!{u64},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeI64) => {
let visitor = Ident::new("visit_i64", Span::call_site());
build_call_visitor(quote!{i64}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
},
Some(FieldType::FieldTypeStruct{struct_name}) => {
Some(quote!{
#label_name => {
reader.set_map_value();
match #struct_name::deserialize(reader) {
Ok(parsed_item) => {
#label = parsed_item;
let _root = reader.next();
},
Err(msg) => {
return Err(msg);
},
}
build_call_visitor(
quote!{i64},
&visitor,
quote!{= value},
&visitor_label,
&label,
&label_name,
)
}
Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
#label_name => {
reader.set_map_value();
match #struct_name::deserialize(reader) {
Ok(parsed_item) => {
#label = parsed_item;
let _root = reader.next();
},
Err(msg) => {
return Err(msg);
},
}
})
},
Some(FieldType::FieldTypeVec{data_type}) => {
}
}),
Some(FieldType::FieldTypeVec { data_type }) => {
let dt = Box::into_raw(data_type);
match unsafe{dt.as_ref()} {
match unsafe { dt.as_ref() } {
Some(&FieldType::FieldTypeString) => {
let visitor = Ident::new("visit_str", Span::call_site());
build_call_visitor(quote!{String}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{String},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeBool) => {
let visitor = Ident::new("visit_bool", Span::call_site());
build_call_visitor(quote!{bool}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{bool},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeI8) => {
let visitor = Ident::new("visit_i8", Span::call_site());
build_call_visitor(quote!{i8}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{i8},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeU8) => {
let visitor = Ident::new("visit_u8", Span::call_site());
build_call_visitor(quote!{u8}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{u8},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeI16) => {
let visitor = Ident::new("visit_i16", Span::call_site());
build_call_visitor(quote!{i16}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{i16},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeU16) => {
let visitor = Ident::new("visit_u16", Span::call_site());
build_call_visitor(quote!{u16}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{u16},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeI32) => {
let visitor = Ident::new("visit_i32", Span::call_site());
build_call_visitor(quote!{i32}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{i32},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeU32) => {
let visitor = Ident::new("visit_u32", Span::call_site());
build_call_visitor(quote!{u32}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{u32},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeI64) => {
let visitor = Ident::new("visit_i64", Span::call_site());
build_call_visitor(quote!{i64}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{i64},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeU64) => {
let visitor = Ident::new("visit_u64", Span::call_site());
build_call_visitor(quote!{u64}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
build_call_visitor(
quote!{u64},
&visitor,
quote!{.push(value)},
&visitor_label,
&label,
&label_name,
)
}
Some(&FieldType::FieldTypeStruct{struct_name}) => {
Some(&FieldType::FieldTypeStruct { struct_name }) => {
let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
Some(quote!{
#label_name => {
@ -370,101 +528,144 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
}
})
}
_ => unimplemented!()
_ => unimplemented!(),
}
},
_ => None
}
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let attributes_loading: Tokens = data_struct.fields.iter().map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if !field_attrs.attribute {
return None;
}
let attributes_loading: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if !field_attrs.attribute {
return None;
}
let label = field.ident;
let label_name =
if let Some(value) = field_attrs.rename {
let label = field.ident;
let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else {
field.ident.unwrap().to_string()
};
match get_field_type(field) {
Some(FieldType::FieldTypeString) => {
Some(quote!{
match get_field_type(field) {
Some(FieldType::FieldTypeString) => Some(quote!{
for attr in attributes {
if attr.name.local_name == #label_name {
#label = attr.value.to_owned();
}
}
})
}
Some(FieldType::FieldTypeStruct{struct_name}) => {
let struct_ident = Ident::new(&format!("__Visitor_{}_{}", label_name, struct_name), Span::call_site());
}),
Some(FieldType::FieldTypeStruct { struct_name }) => {
let struct_ident = Ident::new(
&format!("__Visitor_{}_{}", label_name, struct_name),
Span::call_site(),
);
Some(quote!{
for attr in attributes {
if attr.name.local_name == #label_name {
let visitor = #struct_ident{};
match visitor.visit_str(&attr.value) {
Ok(value) => {#label = value;}
Err(msg) => {return Err(msg);}
Some(quote!{
for attr in attributes {
if attr.name.local_name == #label_name {
let visitor = #struct_ident{};
match visitor.visit_str(&attr.value) {
Ok(value) => {#label = value;}
Err(msg) => {return Err(msg);}
}
}
}
}
})
}
_ => {
None
}
}})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
let set_text: Tokens = data_struct.fields.iter().map(|ref field|
{
let label = field.ident;
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
match get_field_type(field) {
Some(FieldType::FieldTypeString) =>
build_set_text_to_value(&field_attrs, &label, quote!{text_content.to_owned()}),
Some(FieldType::FieldTypeBool) =>
build_set_text_to_value(&field_attrs, &label, quote!{bool::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeI8) =>
build_set_text_to_value(&field_attrs, &label, quote!{i8::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeU8) =>
build_set_text_to_value(&field_attrs, &label, quote!{u8::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeI16) =>
build_set_text_to_value(&field_attrs, &label, quote!{i16::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeU16) =>
build_set_text_to_value(&field_attrs, &label, quote!{u16::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeI32) =>
build_set_text_to_value(&field_attrs, &label, quote!{i32::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeU32) =>
build_set_text_to_value(&field_attrs, &label, quote!{u32::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeI64) =>
build_set_text_to_value(&field_attrs, &label, quote!{i64::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeU64) =>
build_set_text_to_value(&field_attrs, &label, quote!{u64::from_str(text_content).unwrap()}),
Some(FieldType::FieldTypeStruct{..}) |
Some(FieldType::FieldTypeVec{..})|
None => None,
})
}
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut sum, val| {
sum.append_all(val);
sum
});
let struct_builder: Tokens = data_struct.fields.iter().map(|ref field|
{
let set_text: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let label = field.ident;
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
match get_field_type(field) {
Some(FieldType::FieldTypeString) => {
build_set_text_to_value(&field_attrs, &label, quote!{text_content.to_owned()})
}
Some(FieldType::FieldTypeBool) => build_set_text_to_value(
&field_attrs,
&label,
quote!{bool::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeI8) => build_set_text_to_value(
&field_attrs,
&label,
quote!{i8::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeU8) => build_set_text_to_value(
&field_attrs,
&label,
quote!{u8::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeI16) => build_set_text_to_value(
&field_attrs,
&label,
quote!{i16::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeU16) => build_set_text_to_value(
&field_attrs,
&label,
quote!{u16::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeI32) => build_set_text_to_value(
&field_attrs,
&label,
quote!{i32::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeU32) => build_set_text_to_value(
&field_attrs,
&label,
quote!{u32::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeI64) => build_set_text_to_value(
&field_attrs,
&label,
quote!{i64::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeU64) => build_set_text_to_value(
&field_attrs,
&label,
quote!{u64::from_str(text_content).unwrap()},
),
Some(FieldType::FieldTypeStruct { .. }) | Some(FieldType::FieldTypeVec { .. }) | None => {
None
}
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
let struct_builder: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let label = field.ident;
if get_field_type(field).is_some() {
@ -477,7 +678,10 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
quote! {
use xml::reader::XmlEvent;
@ -537,14 +741,22 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
}
}
fn build_default_value(label: &Option<Ident>, field_type: Tokens, default: Tokens) -> Option<Tokens> {
fn build_default_value(
label: &Option<Ident>,
field_type: Tokens,
default: Tokens,
) -> Option<Tokens> {
Some(quote!{
#[allow(unused_mut)]
let mut #label : #field_type = #default;
})
}
fn build_declare_visitor(field_type: Tokens, visitor: &Ident, visitor_label: &Ident) -> Option<Tokens> {
fn build_declare_visitor(
field_type: Tokens,
visitor: &Ident,
visitor_label: &Ident,
) -> Option<Tokens> {
Some(quote!{
#[allow(non_snake_case, non_camel_case_types)]
struct #visitor_label;
@ -558,7 +770,14 @@ fn build_declare_visitor(field_type: Tokens, visitor: &Ident, visitor_label: &Id
})
}
fn build_call_visitor(field_type: Tokens, visitor: &Ident, action: Tokens, visitor_label: &Ident, label: &Option<Ident>, label_name: &String) -> Option<Tokens> {
fn build_call_visitor(
field_type: Tokens,
visitor: &Ident,
action: Tokens,
visitor_label: &Ident,
label: &Option<Ident>,
label_name: &String,
) -> Option<Tokens> {
Some(quote!{
#label_name => {
let visitor = #visitor_label{};
@ -587,8 +806,11 @@ fn build_call_visitor(field_type: Tokens, visitor: &Ident, action: Tokens, visit
})
}
fn build_set_text_to_value(field_attrs: &YaSerdeAttribute, label: &Option<Ident>, action: Tokens) -> Option<Tokens> {
fn build_set_text_to_value(
field_attrs: &YaSerdeAttribute,
label: &Option<Ident>,
action: Tokens,
) -> Option<Tokens> {
if field_attrs.text {
Some(quote!{
#label = #action;

27
yaserde_derive/src/de/mod.rs
View File

@ -1,4 +1,3 @@
pub mod expand_enum;
pub mod expand_struct;
@ -16,20 +15,20 @@ pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<quote::Tokens
let root_attrs = attribute::YaSerdeAttribute::parse(&attrs);
let root = root_attrs.clone().root.unwrap_or(name.to_string());
let impl_block =
match data {
&syn::Data::Struct(ref data_struct) => {
expand_struct::parse(data_struct, &name, &root, &root_attrs.namespaces)
},
&syn::Data::Enum(ref data_enum) => {
expand_enum::parse(data_enum, &name, &root, &root_attrs.namespaces)
},
&syn::Data::Union(ref _data_union) => {
unimplemented!()
},
};
let impl_block = match data {
&syn::Data::Struct(ref data_struct) => {
expand_struct::parse(data_struct, &name, &root, &root_attrs.namespaces)
}
&syn::Data::Enum(ref data_enum) => {
expand_enum::parse(data_enum, &name, &root, &root_attrs.namespaces)
}
&syn::Data::Union(ref _data_union) => unimplemented!(),
};
let dummy_const = Ident::new(&format!("_IMPL_YA_DESERIALIZE_FOR_{}", name), Span::def_site());
let dummy_const = Ident::new(
&format!("_IMPL_YA_DESERIALIZE_FOR_{}", name),
Span::def_site(),
);
let generated = quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]

46
yaserde_derive/src/field_type.rs
View File

@ -1,4 +1,3 @@
use syn;
use syn::punctuated::Pair;
use syn::Type::Path;
@ -15,8 +14,8 @@ pub enum FieldType {
FieldTypeU32,
FieldTypeI64,
FieldTypeU64,
FieldTypeVec{data_type: Box<FieldType>},
FieldTypeStruct{struct_name: syn::Ident},
FieldTypeVec { data_type: Box<FieldType> },
FieldTypeStruct { struct_name: syn::Ident },
}
impl FieldType {
@ -32,37 +31,28 @@ impl FieldType {
"u32" => Some(FieldType::FieldTypeU32),
"i64" => Some(FieldType::FieldTypeI64),
"u64" => Some(FieldType::FieldTypeU64),
"Vec" => {
get_vec_type(t).map(|data_type| {
let p = syn::PathSegment{
ident: data_type,
arguments: syn::PathArguments::None
};
"Vec" => get_vec_type(t).map(|data_type| {
let p = syn::PathSegment {
ident: data_type,
arguments: syn::PathArguments::None,
};
FieldType::FieldTypeVec{
data_type: Box::new(FieldType::from_ident(&p).unwrap())
}
})
},
_struct_name =>
Some(FieldType::FieldTypeStruct{
struct_name: t.ident
}),
FieldType::FieldTypeVec {
data_type: Box::new(FieldType::from_ident(&p).unwrap()),
}
}),
_struct_name => Some(FieldType::FieldTypeStruct {
struct_name: t.ident,
}),
}
}
}
pub fn get_field_type(field: &syn::Field) -> Option<FieldType> {
match field.ty {
Path(ref path) => {
match path.path.segments.first() {
Some(Pair::End(t)) => {
FieldType::from_ident(t)
},
_ => {
None
},
}
Path(ref path) => match path.path.segments.first() {
Some(Pair::End(t)) => FieldType::from_ident(t),
_ => None,
},
_ => None,
}
@ -74,7 +64,7 @@ fn get_vec_type(t: &syn::PathSegment) -> Option<syn::Ident> {
if let &syn::GenericArgument::Type(ref argument) = tt {
if let &Path(ref path2) = argument {
if let Some(Pair::End(ttt)) = path2.path.segments.first() {
return Some(ttt.ident)
return Some(ttt.ident);
}
}
}

4
yaserde_derive/src/lib.rs
View File

@ -1,7 +1,7 @@
#![recursion_limit="256"]
#![recursion_limit = "256"]
extern crate proc_macro;
extern crate proc_macro2;
extern crate proc_macro;
#[macro_use]
extern crate quote;
extern crate syn;

128
yaserde_derive/src/ser/expand_enum.rs
View File

@ -1,4 +1,3 @@
use attribute::*;
use field_type::*;
use quote::Tokens;
@ -8,58 +7,61 @@ use syn::Ident;
use syn::DataEnum;
use proc_macro2::Span;
pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
let write_enum_content : Tokens = data_enum.variants.iter().map(|ref variant|
{
pub fn serialize(
data_enum: &DataEnum,
name: &Ident,
root: &String,
namespaces: &BTreeMap<String, String>,
) -> Tokens {
let write_enum_content: Tokens = data_enum
.variants
.iter()
.map(|ref variant| {
let variant_attrs = YaSerdeAttribute::parse(&variant.attrs);
let renamed_label =
match variant_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident
};
let renamed_label = match variant_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident,
};
let label = variant.ident;
let label_name =
if let Some(prefix) = variant_attrs.prefix {
prefix + ":" + renamed_label.to_string().as_ref()
} else {
renamed_label.to_string()
};
let label_name = if let Some(prefix) = variant_attrs.prefix {
prefix + ":" + renamed_label.to_string().as_ref()
} else {
renamed_label.to_string()
};
match variant.fields {
Fields::Unit => {
Some(quote!{
&#name::#label => {
let data_event = XmlEvent::characters(#label_name);
let _ret = writer.write(data_event);
}
})
},
Fields::Unit => Some(quote!{
&#name::#label => {
let data_event = XmlEvent::characters(#label_name);
let _ret = writer.write(data_event);
}
}),
Fields::Named(ref fields) => {
let enum_fields = fields.named.iter().map(|ref field| {
let enum_fields = fields
.named
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if field_attrs.attribute == true {
return None;
}
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if field_attrs.attribute == true {
return None;
}
let field_label = field.ident;
if field_attrs.text == true {
return Some(quote!(
let field_label = field.ident;
if field_attrs.text == true {
return Some(quote!(
let data_event = XmlEvent::characters(&self.#field_label);
let _ret = writer.write(data_event);
))
}
));
}
let renamed_field_label =
match field_attrs.rename {
let renamed_field_label = match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident
None => field.ident,
};
let field_label_name = renamed_field_label.unwrap().to_string();
let field_label_name = renamed_field_label.unwrap().to_string();
match get_field_type(field) {
Some(FieldType::FieldTypeString) =>
Some(quote!{
match get_field_type(field) {
Some(FieldType::FieldTypeString) => Some(quote!{
match self {
&#name::#label{ref #field_label, ..} => {
let struct_start_event = XmlEvent::start_element(#field_label_name);
@ -74,8 +76,7 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
_ => {},
}
}),
Some(FieldType::FieldTypeStruct{..}) =>
Some(quote!{
Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
let struct_start_event = XmlEvent::start_element(#field_label_name);
let _ret = writer.write(struct_start_event);
@ -92,8 +93,7 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
let struct_end_event = XmlEvent::end_element();
let _ret = writer.write(struct_end_event);
}),
Some(FieldType::FieldTypeVec{..}) =>
Some(quote!{
Some(FieldType::FieldTypeVec { .. }) => Some(quote!{
match self {
&#name::#label{ref #field_label, ..} => {
for item in #field_label {
@ -111,12 +111,15 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
_ => {}
}
}),
_ => None
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
Some(quote!{
&#name::#label{..} => {
@ -129,31 +132,38 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
let _ret = writer.write(struct_end_event);
}
})
},
Fields::Unnamed(ref _fields) => {
unimplemented!()
},
}
Fields::Unnamed(ref _fields) => unimplemented!(),
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
let add_namespaces : Tokens = namespaces.iter().map(|(ref prefix, ref namespace)| {
let add_namespaces: Tokens = namespaces
.iter()
.map(|(ref prefix, ref namespace)| {
Some(quote!(
.ns(#prefix, #namespace)
))
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
quote! {
use xml::writer::XmlEvent;
impl YaSerialize for #name {
#[allow(unused_variables)]
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
-> Result<(), String> {
error!("Enum: start to expand {:?}", #root);
if !writer.skip_start_end() {

313
yaserde_derive/src/ser/expand_struct.rs
View File

@ -1,4 +1,3 @@
use attribute::*;
use field_type::*;
use quote::Tokens;
@ -8,77 +7,88 @@ use syn::DataStruct;
use proc_macro2::Span;
use std::string::ToString;
pub fn serialize(data_struct: &DataStruct, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
let build_attributes : Tokens = data_struct.fields.iter().map(|ref field|
{
pub fn serialize(
data_struct: &DataStruct,
name: &Ident,
root: &String,
namespaces: &BTreeMap<String, String>,
) -> Tokens {
let build_attributes: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if field_attrs.attribute == false {
return None;
}
let renamed_label =
match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident
};
let renamed_label = match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident,
};
let label = field.ident;
let label_name =
if let Some(prefix) = field_attrs.prefix {
prefix + ":" + renamed_label.unwrap().to_string().as_ref()
} else {
renamed_label.unwrap().to_string()
};
let label_name = if let Some(prefix) = field_attrs.prefix {
prefix + ":" + renamed_label.unwrap().to_string().as_ref()
} else {
renamed_label.unwrap().to_string()
};
match get_field_type(field) {
Some(FieldType::FieldTypeString) |
Some(FieldType::FieldTypeBool) |
Some(FieldType::FieldTypeI8) |
Some(FieldType::FieldTypeU8) |
Some(FieldType::FieldTypeI16) |
Some(FieldType::FieldTypeU16) |
Some(FieldType::FieldTypeI32) |
Some(FieldType::FieldTypeU32) |
Some(FieldType::FieldTypeI64) |
Some(FieldType::FieldTypeU64) =>
Some(quote!{
.attr(#label_name, &self.#label)
}),
Some(FieldType::FieldTypeStruct{..}) =>
Some(quote!{
.attr(#label_name, &*{
use std::mem;
match yaserde::ser::to_string_content(&self.#label) {
Ok(value) => {
unsafe {
let ret : &'static str = mem::transmute(&value as &str);
mem::forget(value);
ret
}
},
Err(msg) => return Err("Unable to serialize content".to_owned()),
}
})
}),
_ => {
None
}
Some(FieldType::FieldTypeString)
| Some(FieldType::FieldTypeBool)
| Some(FieldType::FieldTypeI8)
| Some(FieldType::FieldTypeU8)
| Some(FieldType::FieldTypeI16)
| Some(FieldType::FieldTypeU16)
| Some(FieldType::FieldTypeI32)
| Some(FieldType::FieldTypeU32)
| Some(FieldType::FieldTypeI64)
| Some(FieldType::FieldTypeU64) => Some(quote!{
.attr(#label_name, &self.#label)
}),
Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
.attr(#label_name, &*{
use std::mem;
match yaserde::ser::to_string_content(&self.#label) {
Ok(value) => {
unsafe {
let ret : &'static str = mem::transmute(&value as &str);
mem::forget(value);
ret
}
},
Err(msg) => return Err("Unable to serialize content".to_owned()),
}
})
}),
_ => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
let add_namespaces : Tokens = namespaces.iter().map(|(ref prefix, ref namespace)| {
let add_namespaces: Tokens = namespaces
.iter()
.map(|(ref prefix, ref namespace)| {
Some(quote!(
.ns(#prefix, #namespace)
))
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
let struct_inspector : Tokens = data_struct.fields.iter().map(|ref field|
{
let struct_inspector: Tokens = data_struct
.fields
.iter()
.map(|ref field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs);
if field_attrs.attribute == true {
return None;
@ -89,133 +99,130 @@ pub fn serialize(data_struct: &DataStruct, name: &Ident, root: &String, namespac
return Some(quote!(
let data_event = XmlEvent::characters(&self.#label);
let _ret = writer.write(data_event);
))
));
}
let renamed_label =
match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident
};
let renamed_label = match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident,
};
let label_name =
if let Some(prefix) = field_attrs.prefix {
prefix + ":" + renamed_label.unwrap().to_string().as_ref()
} else {
renamed_label.unwrap().to_string()
};
let label_name = if let Some(prefix) = field_attrs.prefix {
prefix + ":" + renamed_label.unwrap().to_string().as_ref()
} else {
renamed_label.unwrap().to_string()
};
match get_field_type(field) {
Some(FieldType::FieldTypeString) =>
Some(quote!{
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
Some(FieldType::FieldTypeString) => Some(quote!{
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let data_event = XmlEvent::characters(&self.#label);
let _ret = writer.write(data_event);
let data_event = XmlEvent::characters(&self.#label);
let _ret = writer.write(data_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}),
Some(FieldType::FieldTypeBool) |
Some(FieldType::FieldTypeI8) |
Some(FieldType::FieldTypeU8) |
Some(FieldType::FieldTypeI16) |
Some(FieldType::FieldTypeU16) |
Some(FieldType::FieldTypeI32) |
Some(FieldType::FieldTypeU32) |
Some(FieldType::FieldTypeI64) |
Some(FieldType::FieldTypeU64) =>
Some(quote!{
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}),
Some(FieldType::FieldTypeBool)
| Some(FieldType::FieldTypeI8)
| Some(FieldType::FieldTypeU8)
| Some(FieldType::FieldTypeI16)
| Some(FieldType::FieldTypeU16)
| Some(FieldType::FieldTypeI32)
| Some(FieldType::FieldTypeU32)
| Some(FieldType::FieldTypeI64)
| Some(FieldType::FieldTypeU64) => Some(quote!{
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let content = format!("{}", &self.#label);
let data_event = XmlEvent::characters(&content);
let _ret = writer.write(data_event);
let content = format!("{}", &self.#label);
let data_event = XmlEvent::characters(&content);
let _ret = writer.write(data_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}),
Some(FieldType::FieldTypeStruct{..}) =>
Some(quote!{
writer.set_skip_start_end(false);
match self.#label.serialize(writer) {
Ok(()) => {},
Err(msg) => {
return Err(msg);
},
};
}),
Some(FieldType::FieldTypeVec{data_type}) => {
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}),
Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
writer.set_skip_start_end(false);
match self.#label.serialize(writer) {
Ok(()) => {},
Err(msg) => {
return Err(msg);
},
};
}),
Some(FieldType::FieldTypeVec { data_type }) => {
let dt = Box::into_raw(data_type);
match unsafe{dt.as_ref()} {
Some(&FieldType::FieldTypeString) => {
Some(quote!{
for item in &self.#label {
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
match unsafe { dt.as_ref() } {
Some(&FieldType::FieldTypeString) => Some(quote!{
for item in &self.#label {
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let data_event = XmlEvent::characters(item);
let _ret = writer.write(data_event);
let data_event = XmlEvent::characters(item);
let _ret = writer.write(data_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}
})
},
Some(&FieldType::FieldTypeBool) |
Some(&FieldType::FieldTypeI8) |
Some(&FieldType::FieldTypeU8) |
Some(&FieldType::FieldTypeI16) |
Some(&FieldType::FieldTypeU16) |
Some(&FieldType::FieldTypeI32) |
Some(&FieldType::FieldTypeU32) |
Some(&FieldType::FieldTypeI64) |
Some(&FieldType::FieldTypeU64) => {
Some(quote!{
for item in &self.#label {
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}
}),
Some(&FieldType::FieldTypeBool)
| Some(&FieldType::FieldTypeI8)
| Some(&FieldType::FieldTypeU8)
| Some(&FieldType::FieldTypeI16)
| Some(&FieldType::FieldTypeU16)
| Some(&FieldType::FieldTypeI32)
| Some(&FieldType::FieldTypeU32)
| Some(&FieldType::FieldTypeI64)
| Some(&FieldType::FieldTypeU64) => Some(quote!{
for item in &self.#label {
let start_event = XmlEvent::start_element(#label_name);
let _ret = writer.write(start_event);
let data_event = XmlEvent::characters(format!("{}", item));
let _ret = writer.write(data_event);
let data_event = XmlEvent::characters(format!("{}", item));
let _ret = writer.write(data_event);
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}
})
},
Some(&FieldType::FieldTypeStruct{..}) => {
Some(quote!{
for item in &self.#label {
writer.set_skip_start_end(false);
match item.serialize(writer) {
Ok(()) => {},
Err(msg) => {
return Err(msg);
},
};
}
})
},
Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
None => {unimplemented!();},
let end_event = XmlEvent::end_element();
let _ret = writer.write(end_event);
}
}),
Some(&FieldType::FieldTypeStruct { .. }) => Some(quote!{
for item in &self.#label {
writer.set_skip_start_end(false);
match item.serialize(writer) {
Ok(()) => {},
Err(msg) => {
return Err(msg);
},
};
}
}),
Some(&FieldType::FieldTypeVec { .. }) => {
unimplemented!();
}
None => {
unimplemented!();
}
}
},
}
None => None,
}
})
.filter(|x| x.is_some())
.map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
.fold(Tokens::new(), |mut tokens, token| {
tokens.append_all(token);
tokens
});
quote! {
use xml::writer::XmlEvent;
impl YaSerialize for #name {
#[allow(unused_variables)]
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
-> Result<(), String> {
error!("Struct: start to expand {:?}", #root);
let skip = writer.skip_start_end();
if !skip {

38
yaserde_derive/src/ser/mod.rs
View File

@ -1,4 +1,3 @@
pub mod expand_enum;
pub mod expand_struct;
@ -16,27 +15,26 @@ pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<quote::Tokens,
let root_attrs = attribute::YaSerdeAttribute::parse(&attrs);
let root = root_attrs.clone().root.unwrap_or(name.to_string());
let root =
if let Some(prefix) = root_attrs.prefix {
prefix + ":" + &root
} else {
root
};
let root = if let Some(prefix) = root_attrs.prefix {
prefix + ":" + &root
} else {
root
};
let impl_block =
match data {
&syn::Data::Struct(ref data_struct) => {
expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
},
&syn::Data::Enum(ref data_enum) => {
expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
},
&syn::Data::Union(ref _data_union) => {
unimplemented!()
},
};
let impl_block = match data {
&syn::Data::Struct(ref data_struct) => {
expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
}
&syn::Data::Enum(ref data_enum) => {
expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
}
&syn::Data::Union(ref _data_union) => unimplemented!(),
};
let dummy_const = Ident::new(&format!("_IMPL_YA_SERIALIZE_FOR_{}", name), Span::def_site());
let dummy_const = Ident::new(
&format!("_IMPL_YA_SERIALIZE_FOR_{}", name),
Span::def_site(),
);
let generated = quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]