Add support for nested models to yaserde (#10)

* Add support for nested models to yaserde

Signed-off-by: Luca Della Vedova <[email protected]>

* Add From for boxed

Signed-off-by: Luca Della Vedova <[email protected]>

---------

Signed-off-by: Luca Della Vedova <[email protected]>

Author: luca-della-vedova

sdformat_rs/build.rs

@@ -81,6 +81,7 @@ struct SDFAttribute {
     required: RequiredStatus,
     default: Option<String>,
     description: String,
+    reference: Option<String>,
 }
 
 impl SDFAttribute {
@@ -91,6 +92,7 @@ impl SDFAttribute {
             required: RequiredStatus::Optional,
             default: None,
             description: "".to_string(),
+            reference: None,
         }
     }
     fn get_field_string(&self) -> String {
@@ -130,6 +132,7 @@ impl SDFElement {
                 required: RequiredStatus::Optional,
                 default: None,
                 description: "".to_string(),
+                reference: None,
             },
             child_elems: vec![],
             child_attrs: vec![],
@@ -160,25 +163,26 @@ impl SDFElement {
         }
         out += "#[derive(Default, PartialEq, Clone, Debug, YaSerialize, YaDeserialize)]\n";
         out += format!("#[yaserde(rename = \"{}\")]\n", self.properties.name).as_str();
-        if self.top_level {
-            out += format!("pub struct {}{} {{\n", prefix_type(prefix), self.typename()).as_str();
-        } else {
-            out += format!(
-                "pub struct {}{} {{\n",
-                prefix_type(prefix),
-                self.properties.name.to_case(Case::Pascal)
-            )
-            .as_str();
-        }
+        out += format!("pub struct {}{} {{\n", prefix_type(prefix), self.typename()).as_str();
         for child in &self.child_attrs {
             out += child.get_field_string().as_str();
         }
 
         let mut child_gen = "".to_string();
-        let name = prefix.to_string().to_case(Case::Pascal) + self.properties.name.as_str();
+        let name = prefix.to_string().to_case(Case::Pascal) + self.typename().as_str();
         for child in &self.child_elems {
             if child.properties.rtype.is_empty() {
                 // TODO(arjo): Handle includes
+                if let Some(reference) = &child.properties.reference {
+                    out += format!(
+                        "  #[yaserde(child, rename = \"{}\")]\n  pub {}: Vec<Boxed<Sdf{}>>,\n",
+                        reference,
+                        reference,
+                        self.typename()
+                    )
+                    .as_str();
+                    continue;
+                }
                 let prefix = prefix_type(&name);
                 child_gen += child.code_gen(prefix.as_str(), file_map).as_str();
                 let typename = prefix + child.properties.name.to_case(Case::Pascal).as_str();
@@ -251,6 +255,9 @@ fn parse_element(model: &mut SDFElement, element: &Element) {
         if let Some(required) = element.attributes.get("required") {
             model.properties.required = RequiredStatus::from_str(required);
         }
+        if let Some(reference) = element.attributes.get("ref") {
+            model.properties.reference = Some(reference.clone());
+        }
     } else if element.name == "attribute" {
         let mut attr = SDFAttribute::new();
         // Parse element description
@@ -282,12 +289,9 @@ fn parse_element(model: &mut SDFElement, element: &Element) {
             if el.name == "attribute" {
                 parse_element(model, el);
             } else if el.name == "element" {
-                if el.attributes.contains_key("ref") {
-                } else {
-                    let mut elem = SDFElement::new();
-                    parse_element(&mut elem, el);
-                    model.child_elems.push(elem);
-                }
+                let mut elem = SDFElement::new();
+                parse_element(&mut elem, el);
+                model.child_elems.push(elem);
             } else if el.name == "include" {
                 let incl = SDFIncludes {
                     filename: el.attributes.get("filename").unwrap().to_string(),

sdformat_rs/src/lib.rs

@@ -1,6 +1,8 @@
 extern crate yaserde_derive;
 use std::collections::{BTreeSet, HashMap};
+use std::fmt::Debug;
 use std::io::{Read, Write};
+use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
 use nalgebra::*;
@@ -14,6 +16,83 @@ use yaserde_derive::{YaDeserialize, YaSerialize};
 // Most of the structs are generated automatically from the
 include!(concat!(env!("OUT_DIR"), "/sdf.rs"));
 
+pub struct Boxed<T> {
+    inner: Box<T>,
+}
+
+impl<T> From<T> for Boxed<T> {
+    fn from(t: T) -> Self {
+        Self {
+            inner: Box::new(t),
+        }
+    }
+}
+
+impl<T: PartialEq> PartialEq for Boxed<T> {
+    fn eq(&self, rhs: &Self) -> bool {
+        self.inner == rhs.inner
+    }
+}
+
+impl<T: YaDeserialize> YaDeserialize for Boxed<T> {
+    fn deserialize<R: Read>(reader: &mut yaserde::de::Deserializer<R>) -> Result<Self, String> {
+        Ok(Self {
+            inner: Box::new(T::deserialize(reader)?),
+        })
+    }
+}
+
+impl<T: YaSerialize> YaSerialize for Boxed<T> {
+    fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
+        self.inner.as_ref().serialize(writer)
+    }
+
+    fn serialize_attributes(
+        &self,
+        attributes: Vec<OwnedAttribute>,
+        namespace: Namespace,
+    ) -> Result<(Vec<OwnedAttribute>, Namespace), String> {
+        self.inner
+            .as_ref()
+            .serialize_attributes(attributes, namespace)
+    }
+}
+
+impl<T: Default> Default for Boxed<T> {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+}
+
+impl<T: Clone> Clone for Boxed<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T: Debug> Debug for Boxed<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.as_ref().fmt(f)
+    }
+}
+
+impl<T> Deref for Boxed<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for Boxed<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
 #[derive(PartialEq, Clone, Debug)]
 pub enum ElementData {
     String(String),

sdformat_rs/tests/camera_test.rs

@@ -102,3 +102,12 @@ fn test_light_direction_pose_serdeser() {
     let serialized = yaserde::ser::to_string(&fr.unwrap()).unwrap();
     assert_eq!(test_syntax.to_string(), serialized);
 }
+
+use sdformat_rs::SdfModel;
+#[test]
+fn test_nested_model() {
+    let test_syntax = "<?xml version=\"1.0\" encoding=\"utf-8\"?><model name=\"top\"><model name=\"nested\" /></model>";
+    let fr = from_str::<SdfModel>(test_syntax);
+    let serialized = yaserde::ser::to_string(&fr.unwrap()).unwrap();
+    assert_eq!(test_syntax.to_string(), serialized);
+}