237 lines
8.7 KiB
Rust
237 lines
8.7 KiB
Rust
|
|
use attribute::*;
|
|
use field_type::*;
|
|
use quote::Tokens;
|
|
use std::collections::BTreeMap;
|
|
use syn::Fields;
|
|
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| {
|
|
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}) => {
|
|
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!();},
|
|
}
|
|
},
|
|
None => None
|
|
}
|
|
|
|
})
|
|
.filter(|x| x.is_some())
|
|
.map(|x| x.unwrap())
|
|
.fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
|
|
|
|
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});
|
|
|
|
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());
|
|
|
|
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});
|
|
|
|
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});
|
|
|
|
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 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
|
|
}
|
|
}
|
|
})
|
|
.filter(|x| x.is_some())
|
|
.map(|x| x.unwrap())
|
|
.fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
|
|
|
|
quote!{
|
|
use xml::reader::XmlEvent;
|
|
|
|
impl YaDeserialize for #name {
|
|
#[allow(unused_variables)]
|
|
fn deserialize<R: Read>(reader: &mut yaserde::de::Deserializer<R>) -> Result<Self, String> {
|
|
let named_element =
|
|
if let XmlEvent::StartElement{name, ..} = reader.peek()?.to_owned() {
|
|
name.local_name.to_owned()
|
|
} else {
|
|
String::from(#root)
|
|
};
|
|
debug!("Enum: start to parse {:?}", named_element);
|
|
|
|
#[allow(unused_assignments, unused_mut)]
|
|
let mut simple_enum_value = None;
|
|
|
|
#variables
|
|
#enum_visitors
|
|
|
|
loop {
|
|
match reader.peek()?.to_owned() {
|
|
XmlEvent::StartElement{name, attributes, namespace: _namespace} => {
|
|
debug!("Enum: {}: {}", named_element, name.local_name.as_str());
|
|
if name.local_name == named_element {
|
|
let _next = reader.next();
|
|
|
|
if let XmlEvent::Characters(content) = reader.peek()?.to_owned() {
|
|
match content.as_str() {
|
|
#match_to_enum
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
XmlEvent::EndElement{name} => {
|
|
if name.local_name.as_str() == named_element {
|
|
break;
|
|
}
|
|
let _root = reader.next();
|
|
},
|
|
xml::reader::XmlEvent::Characters(characters_content) => {
|
|
let _root = reader.next();
|
|
},
|
|
event => {
|
|
return Err(format!("unknown event {:?}", event))
|
|
},
|
|
}
|
|
}
|
|
|
|
match simple_enum_value {
|
|
Some(value) => Ok(value),
|
|
None => {
|
|
Ok(#name::default())
|
|
},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
})
|
|
}
|