1 files changed, 108 insertions, 4 deletions

diff --git a/src/xmlelements.rs b/src/xmlelements.rs
index 86d7c77..bf9a213 100644
--- a/src/xmlelements.rs
+++ b/src/xmlelements.rs
@@ -2,9 +2,32 @@ use ggez::filesystem::File;
 use std::io::BufReader;
 use xml::reader::{
     EventReader,
-    XmlEvent::{self, StartElement},
+    XmlEvent::{self, EndElement, StartElement},
 };
 
+#[derive(Debug)]
+pub struct Property {
+    entity: String,
+    keyframe: usize,
+    delay: usize,
+}
+
+impl Property {
+    pub fn new(property_elements: Vec<XmlEvent>) -> Property {
+
+        let entity = XMLElements::get_attribute_value(&property_elements, "entity").unwrap().parse().unwrap();
+        let keyframe =
+            XMLElements::get_attribute_value(&property_elements, "keyframe").unwrap().parse().unwrap();
+        let delay = XMLElements::get_attribute_value(&property_elements, "delay").unwrap().parse().unwrap();
+
+        Property {
+            entity,
+            keyframe,
+            delay,
+        }
+    }
+}
+
 pub struct XMLElements {
     pub events: Vec<XmlEvent>,
 }
@@ -33,20 +56,101 @@ impl XMLElements {
             .unwrap()
     }
 
+    pub fn get_children(&self, element: &XmlEvent, children_name: &str) -> Vec<XmlEvent> {
+        let start_index = self.events.iter().position(|e| e == element).unwrap();
+
+        let element_name = if let StartElement { name, .. } = element {
+            &name.local_name
+        } else {
+            ""
+        };
+
+        let end_index = self.events[start_index..]
+            .iter()
+            .position(|e| {
+                if let EndElement { name } = e {
+                    element_name == name.local_name
+                } else {
+                    false
+                }
+            })
+            .unwrap()
+            + start_index;
+
+        self.events[start_index..end_index]
+            .iter()
+            .cloned()
+            .filter(|e| {
+                if let StartElement { name, .. } = e {
+                    name.local_name == children_name
+                } else {
+                    false
+                }
+            })
+            .collect()
+    }
+
+    pub fn get_elements(&self, element_name: &str) -> Vec<XmlEvent> {
+        self.events
+            .clone()
+            .into_iter()
+            .filter(|e| {
+                if let StartElement { name, .. } = e {
+                    name.local_name == element_name
+                } else {
+                    false
+                }
+            })
+            .collect()
+    }
+
     pub fn get_element_attribute(
         &self,
         element_name: &str,
         attribute_name: &str,
-    ) -> Result<usize, ()> {
+    ) -> Result<String, ()> {
         let element = self.get_element(element_name);
+        XMLElements::get_attribute(&element, attribute_name)
+    }
+
+    pub fn get_attribute(element: &XmlEvent, attribute_name: &str) -> Result<String, ()> {
         if let StartElement { attributes, .. } = element {
             Ok(attributes
                 .iter()
                 .find(|a| a.name.local_name == attribute_name)
                 .unwrap()
                 .value
-                .parse()
-                .unwrap())
+                .clone())
+        } else {
+            Err(())
+        }
+    }
+
+    pub fn get_attribute_value(
+        elements: &Vec<XmlEvent>,
+        attribute_name: &str,
+    ) -> Result<String, ()> {
+        let element = elements
+            .iter()
+            .find(|e| {
+                if let StartElement { attributes, .. } = e {
+                    attributes
+                        .iter()
+                        .find(|a| a.value == attribute_name)
+                        .is_some()
+                } else {
+                    false
+                }
+            })
+            .unwrap();
+
+        if let StartElement { attributes, .. } = element {
+            Ok(attributes
+                .iter()
+                .find(|a| a.name.local_name == "value")
+                .unwrap()
+                .value
+                .clone())
         } else {
             Err(())
         }