[WIP] Adding encode functions to SVD elements

src/access.rs

@@ -0,0 +1,80 @@
+extern crate xmltree;
+
+use std::collections::HashMap;
+
+use xmltree::Element;
+
+use helpers::*;
+
+macro_rules! try {
+    ($e:expr) => {
+        $e.expect(concat!(file!(), ":", line!(), " ", stringify!($e)))
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Access {
+    ReadOnly,
+    ReadWrite,
+    ReadWriteOnce,
+    WriteOnce,
+    WriteOnly,
+}
+
+impl ParseElem for Access {
+    fn parse(tree: &Element) -> Access {
+        let text = try!(tree.text.as_ref());
+
+        match &text[..] {
+            "read-only" => Access::ReadOnly,
+            "read-write" => Access::ReadWrite,
+            "read-writeOnce" => Access::ReadWriteOnce,
+            "write-only" => Access::WriteOnly,
+            "writeOnce" => Access::WriteOnce,
+            _ => panic!("unknown access variant: {}", text),
+        }
+    }
+}
+
+impl EncodeElem for Access {
+    fn encode(&self) -> Element {
+        let text = match *self {
+            Access::ReadOnly => String::from("read-only"),
+            Access::ReadWrite => String::from("read-write"),
+            Access::ReadWriteOnce => String::from("read-writeOnce"),
+            Access::WriteOnly => String::from("write-only"),
+            Access::WriteOnce => String::from("writeOnce"),
+        };
+
+        Element{
+            name: String::from("access"),
+            attributes: HashMap::new(),
+            children: Vec::new(),
+            text: Some(text),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decode_encode() {
+        let types = vec![
+            (Access::ReadOnly,        String::from("<access>read-only</access>")),
+            (Access::ReadWrite,       String::from("<access>read-write</access>")),
+            (Access::ReadWriteOnce,   String::from("<access>read-writeOnce</access>")),
+            (Access::WriteOnly,       String::from("<access>write-only</access>")),
+            (Access::WriteOnce,       String::from("<access>writeOnce</access>"))
+        ];
+
+        for (a, s) in types {
+            let tree1 = &try!(Element::parse(s.as_bytes()));
+            let access = Access::parse(tree1);
+            assert_eq!(access, a, "Parsing `{}` expected `{:?}`", s, a);
+            let tree2 = &access.encode();
+            assert_eq!(tree1, tree2, "Encoding {:?} expected {}", a, s);
+        }
+    }
+}

src/endian.rs

@@ -0,0 +1,76 @@
+extern crate xmltree;
+
+use std::collections::HashMap;
+
+use xmltree::Element;
+
+use helpers::*;
+
+macro_rules! try {
+    ($e:expr) => {
+        $e.expect(concat!(file!(), ":", line!(), " ", stringify!($e)))
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Endian {
+    Little,
+    Big,
+    Selectable,
+    Other
+}
+
+impl ParseElem for Endian {
+    fn parse(tree: &Element) -> Endian {
+        let text = try!(tree.text.as_ref());
+
+        match &text[..] {
+            "little" => Endian::Little,
+            "big" => Endian::Big,
+            "selectable" => Endian::Selectable,
+            "other" => Endian::Other,
+            _ => panic!("unknown endian variant: {}", text),
+        }
+    }
+}
+
+impl EncodeElem for Endian {
+    fn encode(&self) -> Element {
+        let text = match *self {
+            Endian::Little => String::from("little"),
+            Endian::Big => String::from("big"),
+            Endian::Selectable => String::from("selectable"),
+            Endian::Other => String::from("other"),
+        };
+
+        Element{
+            name: String::from("endian"),
+            attributes: HashMap::new(),
+            children: Vec::new(),
+            text: Some(text),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decode_encode() {
+        let types = vec![
+            (Endian::Little,        String::from("<endian>little</endian>")),
+            (Endian::Big,           String::from("<endian>big</endian>")),
+            (Endian::Selectable,    String::from("<endian>selectable</endian>")),
+            (Endian::Other,         String::from("<endian>other</endian>"))
+        ];
+
+        for (e, s) in types {
+            let tree1 = &try!(Element::parse(s.as_bytes()));
+            let endian = Endian::parse(tree1);
+            assert_eq!(endian, e, "Parsing `{}` expected `{:?}`", s, e);
+            let tree2 = &endian.encode();
+            assert_eq!(tree1, tree2, "Encoding {:?} expected {}", e, s);
+        }
+    }
+}

src/enumeratedvalue.rs

@@ -0,0 +1,115 @@
+extern crate xmltree;
+
+use std::collections::HashMap;
+
+use xmltree::Element;
+use ElementExt;
+
+use helpers::*;
+use parse;
+
+macro_rules! try {
+    ($e:expr) => {
+        $e.expect(concat!(file!(), ":", line!(), " ", stringify!($e)))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EnumeratedValue {
+    pub name: String,
+    pub description: Option<String>,
+    pub value: Option<u32>,
+    pub is_default: Option<bool>,
+    // Reserve the right to add more fields to this struct
+    pub _extensible: (),
+}
+
+impl EnumeratedValue {
+    pub fn parse(tree: &Element) -> Option<EnumeratedValue> {
+        assert_eq!(tree.name, "enumeratedValue");
+
+        Some(
+            EnumeratedValue {
+                name: try!(tree.get_child_text("name")),
+                description: tree.get_child_text("description"),
+                value: tree.get_child("value").map(|t| try!(parse::u32(t))),
+                is_default: tree.get_child_text("isDefault").map(
+                    |t| {
+                        try!(t.parse())
+                    },
+                ),
+                _extensible: (),
+            },
+        )
+    }
+}
+
+impl EncodeElem for EnumeratedValue {
+    fn encode(&self) -> Element {
+        let mut base = Element{
+            name: String::from("enumeratedValue"),
+            attributes: HashMap::new(),
+            children: vec![
+                new_element("name", Some(self.name.clone())),
+            ],
+            text: None,
+        };
+
+        match self.description {
+            Some(ref d) => {
+                let s = (*d).clone();
+                base.children.push(new_element("description", Some(s)));
+            },
+            None => (),
+        };
+
+        match self.value {
+            Some(ref v) => {
+                base.children.push(new_element("value", Some(format!("0x{:08.x}", *v))));
+            },
+            None => (),
+        };
+
+        match self.is_default {
+            Some(ref v) => {
+                base.children.push(new_element("isDefault", Some(format!("{}", v))));
+            },
+            None => (),
+        };
+
+        base
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decode_encode() {
+        let example = String::from("
+            <enumeratedValue>
+                <name>WS0</name>
+                <description>Zero wait-states inserted in fetch or read transfers</description>
+                <value>0x00000000</value>
+                <isDefault>true</isDefault>
+            </enumeratedValue>
+        ");
+        let expected = EnumeratedValue{
+            name: String::from("WS0"),
+            description: Some(String::from("Zero wait-states inserted in fetch or read transfers")),
+            value: Some(0),
+            is_default: Some(true),
+            _extensible: (),
+        };
+
+        let tree1 = &try!(Element::parse(example.as_bytes()));
+
+        let parsed = EnumeratedValue::parse(tree1).unwrap();
+        assert_eq!(parsed, expected, "Parsing tree failed");
+
+        let tree2 = &parsed.encode();
+        assert_eq!(tree1, tree2, "Encoding value failed");
+    }
+}