Working on encode functions

Trying out merge extension for non-element objects

Author: ryankurte

src/lib.rs

@@ -64,6 +64,8 @@ trait ElementExt {
     fn get_child_u32(&self, n: &str) -> Result<u32, SVDError>;
     fn get_child_bool(&self, n: &str) -> Result<bool, SVDError>;
 
+    fn merge(&self, n: &Self) -> Self;
+
     fn debug(&self);
 }
 
@@ -120,6 +122,15 @@ impl ElementExt for Element {
         BoolParse::parse(s)
     }
 
+    // Merges the children of two elements, maintaining the name and description of the first
+    fn merge(&self, r: &Self) -> Self {
+        let mut n = self.clone();
+        for c in  &r.children {
+            n.children.push(c.clone());
+        }
+        n
+    }
+
     fn debug(&self) {
         println!("<{}>", self.name);
         for c in &self.children {

src/parse.rs

@@ -55,10 +55,13 @@ impl Parse for DimIndex {
         }
     }
 }
+
+//TODO: encode for DimIndex
+
+
 /// Parses an optional child element with the provided name and Parse function
 /// Returns an none if the child doesn't exist, Ok(Some(e)) if parsing succeeds,
 /// and Err() if parsing fails.
-/// TODO: suspect we should be able to use the Parse trait here
 pub fn optional<'a, T>(n: &str, e: &'a Element) -> Result<Option<T::Object>, SVDError>
 where T: Parse<Error = SVDError>
 {

src/svd/cluster.rs

@@ -2,6 +2,8 @@
 use std::ops::Deref;
 use xmltree::Element;
 
+use ElementExt;
+
 use types::{Parse, Encode};
 use error::*;
 use ::svd::clusterinfo::ClusterInfo;
@@ -33,12 +35,17 @@ impl Parse for Cluster {
         let info = ClusterInfo::parse(tree)?;
 
         if tree.get_child("dimIncrement").is_some() {
-            // TODO: s/assert/errors/g
             let array_info = RegisterClusterArrayInfo::parse(tree)?;
-            assert!(info.name.contains("%s"));
+            if !info.name.contains("%s") {
+                // TODO: replace with real error
+                return Err(SVDError::from(SVDErrorKind::Other("Cluster name invalid".to_string())));
+            }
 
             if let Some(ref indices) = array_info.dim_index {
-                assert_eq!(array_info.dim as usize, indices.len())
+                if array_info.dim as usize != indices.len() {
+                    // TODO: replace with real error
+                    return Err(SVDError::from(SVDErrorKind::Other("Cluster index length mismatch".to_string())));
+                }
             }
 
             Ok(Cluster::Array(info, array_info))
@@ -52,7 +59,18 @@ impl Encode for Cluster {
     type Error = SVDError;
     // TODO: support Cluster encoding
     fn encode(&self) -> Result<Element, SVDError> {
-        Err(SVDError::from(SVDErrorKind::EncodeNotImplemented(String::from("RegisterClusterArrayInfo"))))
+        match self {
+            Cluster::Single(i) => {
+                let mut e = i.encode()?;
+                Ok(e)
+            },
+            Cluster::Array(i, a) => {
+                let mut e = i.encode()?;
+                e = e.merge(&a.encode()?);
+                Ok(e)
+            }
+        }
+        
     }
 }
 

src/svd/clusterinfo.rs

@@ -6,7 +6,7 @@ use ElementExt;
 use types::{Parse, Encode, new_element};
 use parse;
 
-use ::error::{SVDError, SVDErrorKind};
+use ::error::{SVDError};
 use ::svd::access::Access;
 use ::svd::registercluster::RegisterCluster;
 
@@ -60,10 +60,37 @@ impl Parse for ClusterInfo {
 impl Encode for ClusterInfo {
     type Error = SVDError;
     fn encode(&self) -> Result<Element, SVDError> {
-        // TODO: support ClusterInfo encoding
-        let _ = new_element("fake", None);
+        let mut e = new_element("cluster", None);
 
-        Err(SVDError::from(SVDErrorKind::EncodeNotImplemented(String::from("RegisterClusterArrayInfo"))))
+        e.children.push(new_element("description", Some(self.description.clone())));
+
+        if let Some(ref v) = self.header_struct_name {
+            e.children.push(new_element("headerStructName", Some(v.clone())));
+        }
+
+        e.children.push(new_element("addressOffset", Some(format!("{}", self.address_offset))));
+
+        if let Some(ref v) = self.size {
+            e.children.push(new_element("size", Some(format!("{}", v))));
+        }
+
+        if let Some(ref v) = self.access {
+            e.children.push(v.encode()?);
+        }
+
+        if let Some(ref v) = self.reset_value {
+            e.children.push(new_element("resetValue", Some(format!("{}", v))));
+        }
+
+        if let Some(ref v) = self.reset_mask {
+            e.children.push(new_element("resetMask", Some(format!("{}", v))));
+        }
+
+        for c in &self.children {
+            e.children.push(c.encode()?);
+        }
+
+        Ok(e)
     }
 }
 

src/svd/registerclusterarrayinfo.rs

@@ -5,13 +5,15 @@ use parse;
 use types::{Parse, Encode, new_element};
 use ElementExt;
 
-use ::error::{SVDError, SVDErrorKind};
+use ::error::{SVDError};
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct RegisterClusterArrayInfo {
     pub dim: u32,
     pub dim_increment: u32,
     pub dim_index: Option<Vec<String>>,
+    // Reserve the right to add more fields to this struct
+    _extensible: (),
 }
 
 impl Parse for RegisterClusterArrayInfo {
@@ -23,18 +25,52 @@ impl Parse for RegisterClusterArrayInfo {
             dim: tree.get_child_u32("dim")?,
             dim_increment: tree.get_child_u32("dimIncrement")?,
             dim_index: parse::optional::<parse::DimIndex>("dimIndex", tree)?,
+            _extensible: (),
         })
     }
 }
 
 impl Encode for RegisterClusterArrayInfo {
     type Error = SVDError;
+
     fn encode(&self) -> Result<Element, SVDError> {
-        // TODO: support RegisterClusterArrayInfo encoding
-        let _ = new_element("fake", None);
+        let mut e = new_element("registerClusterArrayInfo", None);
+
+        e.children.push(new_element("dim", Some(format!("{}", self.dim))));
+        e.children.push(new_element("dimIncrement", Some(format!("{}", self.dim_increment))));
 
-        Err(SVDError::from(SVDErrorKind::EncodeNotImplemented(String::from("RegisterClusterArrayInfo"))))
+        if let Some(ref di) = self.dim_index {
+            //TODO: this should be a join, but I don't have docs rn
+            e.children.push(new_element("dimIndex", Some(format!("{},{}", di[0], di[1]))));
+        }
+
+        Ok(e)
     }
 }
 
-//TODO: test RegisterClusterArrayInfo encode and decode
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use types::test;
+
+    #[test]
+    fn decode_encode() {          
+        let tests = vec![
+            (RegisterClusterArrayInfo {
+                dim: 100,
+                dim_increment: 4,
+                dim_index: Some(vec!["10".to_owned(), "20".to_owned()]),
+                _extensible: (),
+            },
+            "<registerClusterArrayInfo>
+                <dim>100</dim>
+                <dimIncrement>4</dimIncrement>
+                <dimIndex>10,20</dimIndex>
+            </registerClusterArrayInfo>
+            ")
+        ];
+
+        test::<RegisterClusterArrayInfo>(&tests[..]);
+    }
+}