Parsing main infoemations from xml

Author: whizsid

src/main.rs

@@ -1,14 +1,23 @@
 pub mod node;
 use node::Node;
 
+pub mod way;
+use way::Way;
+
+pub mod relation;
+use relation::Relation;
+
 pub mod main_info;
 use main_info::MainInfo;
+use main_info::Attr;
+// use main_info::Tag;
 
 pub mod argument;
 use argument::Arguments;
 
 use quick_xml::events::Event;
 use quick_xml::Reader;
+
 use std::env;
 use std::path::Path;
 
@@ -21,22 +30,64 @@ fn main() {
 
  // let mut count = 0;
  let mut buf = Vec::new();
- // The `Reader` does not implement `Iterator` because it outputs borrowed data (`Cow`s)
  match result {
- Ok(mut reader) => loop {
- match reader.read_event(&mut buf) {
- Ok(Event::Start(e)) => match e.name() {
- b"node" => println!(
- "attributes values: {:?}",
- e.attributes().map(|a| a.unwrap().value).collect::<Vec<_>>()
- ),
+ Ok(mut reader) =>{ 
+ // Self closing tags
+ reader.expand_empty_elements(true);
+
+ loop {
+ match reader.read_event(&mut buf) {
+ Ok(Event::Start(e)) => match e.name() {
+ b"node" => {
+ let mut node:Node = Node {..Default::default()};
+
+ e.attributes().for_each(|a| match a {
+ Ok(attr)=>{
+ 
+ let formated_attr = Attr::from_quick_xml(attr);
+ let value = formated_attr.value.clone();
+ let name = formated_attr.name.clone();
+
+ if !node.main_info.set_attribute(formated_attr) {
+ match name.as_ref() {
+ "lat"=> node.lat = value.parse::<f32>().unwrap(),
+ "lon"=> node.lng = value.parse::<f32>().unwrap(),
+ _=>(),
+ }
+ }
+ },
+ Err(e)=>panic!("{:?}",e)
+ });
+ },
+ b"way"=>{
+ let mut way:Way = Way {..Default::default()};
+
+ e.attributes().for_each(|a| match a {
+ Ok(attr)=>{
+ way.main_info.set_attribute(Attr::from_quick_xml(attr));
+ },
+ Err(e)=>panic!("{:?}",e)
+ });
+ },
+ b"relation"=>{
+ let mut relation:Relation = Relation {..Default::default()};
+
+ e.attributes().for_each(|a| match a {
+ Ok(attr)=>{
+ relation.main_info.set_attribute(Attr::from_quick_xml(attr));
+ },
+ Err(e)=>panic!("{:?}",e)
+ });
+
+ },
+ _ => (),
+ },
+ Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
+ Ok(Event::Eof) => break,
  _ => (),
- },
- Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
- Ok(Event::Eof) => break,
- _ => (),
+ }
+ buf.clear();
  }
- buf.clear();
  },
  Err(e) => panic!("Invalid file :- {:?}", e),
  }

src/main_info.rs

@@ -1,14 +1,92 @@
+use quick_xml::events::attributes::Attribute;
+use std::str;
+
 pub struct MainInfo {
- pub changeset:i16,
- pub id: i16,
+ pub changeset:i32,
+ pub id: i32,
  pub version: i8,
  pub timestamp: String,
  pub user: String,
- pub uid: i16,
+ pub uid: i32,
  pub visible: bool,
  pub tags: Vec<UsedTag>,
 }
 
+impl Default for MainInfo {
+ fn default()->MainInfo{
+ MainInfo {
+ id: 00000,
+ version: 8,
+ changeset: 000000,
+ timestamp: String::from("2011-01-12T14:23:49Z"),
+ user: String::from("anonymous"),
+ uid: 0000,
+ visible: true,
+ tags: vec!()
+ }
+ }
+}
+
+impl MainInfo {
+ pub fn set_attribute(&mut self, attr:crate::main_info::Attr)->bool{
+ match attr.name.as_ref() {
+ "id"=>{
+ self.id = attr.value.parse::<i32>().unwrap();
+ return true;
+ } ,
+ "version" => {
+ self.version = attr.value.parse::<i8>().unwrap();
+ return true;
+ },
+ "changeset"=>{
+ self.changeset = attr.value.parse::<i32>().unwrap();
+ return true;
+ },
+ "timestamp"=>{
+ self.timestamp = attr.value;
+ return true;
+ },
+ "user"=>{
+ self.user = attr.value;
+ return true;
+ },
+ "uid"=>{
+ self.uid = attr.value.parse::<i32>().unwrap();
+ return true;
+ },
+ "visible"=>{
+ self.visible = attr.value=="true";
+ return true;
+ },
+ _=>false
+ }
+ }
+}
+
+pub struct Attr {
+ pub name: String,
+ pub value: String
+}
+
+impl Attr {
+ pub fn from_quick_xml (attr:Attribute)->Attr{
+ let value = match str::from_utf8(& attr.value){
+ Ok(ret_str)=>ret_str,
+ Err(e)=>panic!("Attribute value error: {:?}",e)
+ };
+
+ let name = match str::from_utf8(attr.key){
+ Ok(ret_str)=>ret_str,
+ Err(e)=>panic!("Attribute name error: {:?}",e)
+ };
+
+ return Attr {
+ value: value.to_owned(),
+ name: name.to_owned()
+ }
+ }
+}
+
 pub struct Tag {
  pub id: i16,
  pub name: String,

src/node.rs

@@ -2,4 +2,16 @@ pub struct Node {
  pub main_info: crate::main_info::MainInfo,
  pub lat: f32,
  pub lng: f32
+}
+
+impl Default for Node {
+ fn default()->Node {
+ Node {
+ main_info: crate::main_info::MainInfo {
+ ..Default::default()
+ },
+ lat: 3232.3232323,
+ lng: 232.232323232
+ }
+ }
 }

src/relation.rs

@@ -9,3 +9,12 @@ pub struct Relation {
  pub members: Vec<Member>,
  pub main_info: crate::main_info::MainInfo
 }
+
+impl Default for Relation {
+ fn default()->Relation {
+ Relation {
+ members: vec![],
+ main_info: crate::main_info::MainInfo { .. Default::default()}
+ }
+ }
+}

src/way.rs

@@ -1,4 +1,13 @@
 pub struct Way {
  pub nodes: Vec<i8>,
  pub main_info: crate::main_info::MainInfo,
+}
+
+impl Default for Way {
+ fn default()->Way {
+ Way {
+ main_info: crate::main_info::MainInfo {.. Default::default()},
+ nodes: vec![]
+ }
+ }
 }