use anytime FieldType methods

yaserde_derive/src/de/expand_struct.rs

@@ -4,45 +4,29 @@ use field_type::*;
 use quote::Tokens;
 use syn::Ident;
 use syn::DataStruct;
-use syn::punctuated::Pair;
-use syn::Type::Path;
 use proc_macro2::Span;
 
 pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String) -> Tokens {
   let variables : Tokens = data_struct.fields.iter().map(|ref field|
     {
       let label = field.ident;
-
+      match get_field_type(field) {
-      match field.ty {
+        Some(FieldType::FieldTypeString) => {
-        Path(ref path) => {
+          Some(quote!{
-          match path.path.segments.first() {
+            let mut #label : String = "".to_string();
-            Some(Pair::End(t)) => {
+          })
-              let pair = path.path.segments.first().unwrap();
-
-              match t.ident.to_string().as_str() {
-                "String" => {
-                  Some(quote!{
-                    let mut #label : #pair = "".to_string();
-                  })
-                },
-                "Vec" => {
-                  Some(quote!{
-                    let mut #label : #pair = vec![];
-                  })
-                },
-                _ => {
-                  Some(quote!{
-                    let mut #label : #pair = #pair::default();
-                  })
-                },
-              }
-            },
-            _ => {
-              None
-            },
-          }
         },
-        _ => {None},
+        Some(FieldType::FieldTypeVec{data_type}) => {
+          Some(quote!{
+            let mut #label : Vec<#data_type> = vec![];
+          })
+        },
+        Some(FieldType::FieldTypeStruct{struct_name}) => {
+          Some(quote!{
+            let mut #label : #struct_name = #struct_name::default();
+          })
+        }
+        _ => None
       }
     })
     .filter(|x| x.is_some())
@@ -142,8 +126,8 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String) -> Tokens {
             },
           })
         },
-        Some(FieldType::FieldTypeStruct{name}) => {
+        Some(FieldType::FieldTypeStruct{struct_name}) => {
-          let struct_ident = Ident::new(&format!("{}", name), Span::def_site());
+          let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
 
           Some(quote!{
             #label_name => {
@@ -159,41 +143,36 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String) -> Tokens {
             },
           })
         },
-        Some(FieldType::FieldTypeVec) => {
+        Some(FieldType::FieldTypeVec{data_type}) => {
-          match get_vec_type(field) {
+          match data_type.to_string().as_str() {
-            Some(identifier) => {
+            "String" => {
-              match identifier.to_string().as_str() {
+              Some(quote!{
-                "String" => {
+                #label_name => {
-                  Some(quote!{
+                  match read.next() {
-                    #label_name => {
+                    Ok(xml::reader::XmlEvent::Characters(characters_content)) => {
-                      match read.next() {
+                      #label.push(characters_content.trim().to_string());
-                        Ok(xml::reader::XmlEvent::Characters(characters_content)) => {
-                          #label.push(characters_content.trim().to_string());
-                        },
-                        _ => {},
-                      }
                     },
-                  })
+                    _ => {},
+                  }
                 },
-                struct_name => {
+              })
-                  let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
-                  Some(quote!{
-                    #label_name => {
-                      match #struct_ident::derive_deserialize(read, Some(&attributes)) {
-                        Ok(parsed_item) => {
-                          prev_level -= 1;
-                          #label.push(parsed_item);
-                        },
-                        Err(msg) => {
-                          println!("ERROR {:?}", msg);
-                        },
-                      }
-                    },
-                  })
-                }
-              }
             },
-            None => None
+            struct_name => {
+              let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
+              Some(quote!{
+                #label_name => {
+                  match #struct_ident::derive_deserialize(read, Some(&attributes)) {
+                    Ok(parsed_item) => {
+                      prev_level -= 1;
+                      #label.push(parsed_item);
+                    },
+                    Err(msg) => {
+                      println!("ERROR {:?}", msg);
+                    },
+                  }
+                },
+              })
+            }
           }
         },
         _ => None
@@ -210,7 +189,7 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String) -> Tokens {
       match get_field_type(field) {
         Some(FieldType::FieldTypeString) |
         Some(FieldType::FieldTypeStruct{..}) |
-        Some(FieldType::FieldTypeVec) =>
+        Some(FieldType::FieldTypeVec{..}) =>
           Some(quote!{
             #label: #label,
           }),

yaserde_derive/src/field_type.rs

@@ -6,8 +6,8 @@ use syn::Type::Path;
 #[derive(Debug)]
 pub enum FieldType {
   FieldTypeString,
-  FieldTypeVec,
+  FieldTypeVec{data_type: syn::Ident},
-  FieldTypeStruct{name: String},
+  FieldTypeStruct{struct_name: syn::Ident},
 }
 
 pub fn get_field_type(field: &syn::Field) -> Option<FieldType> {
@@ -17,8 +17,19 @@ pub fn get_field_type(field: &syn::Field) -> Option<FieldType> {
         Some(Pair::End(t)) => {
           match t.ident.to_string().as_str() {
             "String" => Some(FieldType::FieldTypeString),
-            "Vec" => Some(FieldType::FieldTypeVec),
+            "Vec" => {
-            name => Some(FieldType::FieldTypeStruct{name: name.to_string()}),
+              match get_vec_type(t) {
+                Some(data_type) =>
+                  Some(FieldType::FieldTypeVec{
+                    data_type: data_type
+                  }),
+                None => None,
+              }
+            },
+            _struct_name =>
+              Some(FieldType::FieldTypeStruct{
+                struct_name: t.ident
+              }),
           }
         },
         _ => {
@@ -30,28 +41,18 @@ pub fn get_field_type(field: &syn::Field) -> Option<FieldType> {
   }
 }
 
-pub fn get_vec_type(field: &syn::Field) -> Option<syn::Ident> {
+fn get_vec_type(t: &syn::PathSegment) -> Option<syn::Ident> {
-  match field.ty {
+  match t.arguments {
-    Path(ref path) => {
+    syn::PathArguments::AngleBracketed(ref args) => {
-      match path.path.segments.first() {
+      match args.args.first() {
-        Some(Pair::End(t)) => {
+        Some(Pair::End(tt)) => {
-          match t.arguments {
+          match tt {
-            syn::PathArguments::AngleBracketed(ref args) => {
+            &syn::GenericArgument::Type(ref argument) => {
-              match args.args.first() {
+              match argument {
-                Some(Pair::End(tt)) => {
+                &Path(ref path2) => {
-                  match tt {
+                  match path2.path.segments.first() {
-                    &syn::GenericArgument::Type(ref argument) => {
+                    Some(Pair::End(ttt)) => {
-                      match argument {
+                      Some(ttt.ident)
-                        &Path(ref path2) => {
-                          match path2.path.segments.first() {
-                            Some(Pair::End(ttt)) => {
-                              Some(ttt.ident)
-                            },
-                            _ => None
-                          }
-                        },
-                        _ => None
-                      }
                     },
                     _ => None
                   }
@@ -64,7 +65,7 @@ pub fn get_vec_type(field: &syn::Field) -> Option<syn::Ident> {
         },
         _ => None
       }
-    }
+    },
     _ => None
   }
 }

yaserde_derive/src/ser/expand_struct.rs

@@ -75,7 +75,7 @@ pub fn serialize(data_struct: &DataStruct, name: &Ident, root: &String) -> Token
               },
             };
           }),
-        Some(FieldType::FieldTypeVec) =>
+        Some(FieldType::FieldTypeVec{..}) =>
           Some(quote!{
             for item in &self.#label {
               let start_event = XmlEvent::start_element(#label_name);