✨ xmlgen: Maintain definition order

zbus/tests/iface_and_proxy/client.rs

@@ -70,13 +70,12 @@ pub async fn my_iface_test(conn: Connection, event: Event) -> zbus::Result<u32>
         .find(|i| i.name() == "org.freedesktop.MyIface")
         .unwrap();
     // Test if the r# prefix for the keyword was removed
-    assert!(my_iface.methods().iter().any(|m| m.name() == "Type"));
-    assert!(my_iface.properties().iter().any(|p| p.name() == "Let"));
-    assert!(my_iface.signals().iter().any(|s| s.name() == "Match"));
+    assert!(my_iface.methods().any(|m| m.name() == "Type"));
+    assert!(my_iface.properties().any(|p| p.name() == "Let"));
+    assert!(my_iface.signals().any(|s| s.name() == "Match"));
     assert_eq!(
         my_iface
             .methods()
-            .iter()
             .find(|m| m.name() == "RawIdentifierParameter")
             .unwrap()
             .args()

zbus_xml/src/lib.rs

@@ -436,18 +436,8 @@ pub struct Interface<'a> {
     #[serde(rename = "@name", borrow)]
     name: InterfaceName<'a>,
 
-    #[serde(rename = "method", default)]
-    methods: Vec<Method<'a>>,
-    #[serde(rename = "property", default)]
-    properties: Vec<Property<'a>>,
-    #[serde(rename = "signal", default)]
-    signals: Vec<Signal<'a>>,
-    #[serde(rename = "annotation", default)]
-    annotations: Vec<Annotation>,
-    #[serde(skip)]
-    docstring: Option<String>,
-    #[serde(skip)]
-    telepathy_types: Vec<telepathy::TypeDef>,
+    #[serde(default)]
+    children: Vec<Child<'a>>,
 }
 
 impl<'a> Interface<'a> {
@@ -457,23 +447,47 @@ impl<'a> Interface<'a> {
     }
 
     /// Returns the interface methods.
-    pub fn methods(&self) -> &[Method<'a>] {
-        &self.methods
+    pub fn methods(&self) -> impl Iterator<Item = &Method<'a>> {
+        self.children.iter().filter_map(|child| {
+            if let Child::Method(m) = child {
+                Some(m)
+            } else {
+                None
+            }
+        })
     }
 
     /// Returns the interface signals.
-    pub fn signals(&self) -> &[Signal<'a>] {
-        &self.signals
+    pub fn signals(&self) -> impl Iterator<Item = &Signal<'a>> {
+        self.children.iter().filter_map(|child| {
+            if let Child::Signal(s) = child {
+                Some(s)
+            } else {
+                None
+            }
+        })
     }
 
     /// Returns the interface properties.
-    pub fn properties(&self) -> &[Property<'_>] {
-        &self.properties
+    pub fn properties(&self) -> impl Iterator<Item = &Property<'a>> {
+        self.children.iter().filter_map(|child| {
+            if let Child::Property(p) = child {
+                Some(p)
+            } else {
+                None
+            }
+        })
     }
 
     /// Return the associated annotations.
-    pub fn annotations(&self) -> &[Annotation] {
-        &self.annotations
+    pub fn annotations(&self) -> impl Iterator<Item = &Annotation> {
+        self.children.iter().filter_map(|child| {
+            if let Child::Annotation(a) = child {
+                Some(a)
+            } else {
+                None
+            }
+        })
     }
 
     /// Return the content of the Telepathy `tp:docstring` extension element, if any.
@@ -482,40 +496,110 @@ impl<'a> Interface<'a> {
     /// surrounding whitespace trimmed. Note that docstrings are only captured when parsing;
     /// the writer does not emit them.
     pub fn docstring(&self) -> Option<&str> {
-        self.docstring.as_deref()
+        self.children
+            .iter()
+            .filter_map(|child| {
+                if let Child::Docstring(s) = child {
+                    Some(s.as_ref())
+                } else {
+                    None
+                }
+            })
+            .next()
     }
 
     /// Return the Telepathy type definitions on this interface.
-    pub fn telepathy_types(&self) -> &[telepathy::TypeDef] {
-        &self.telepathy_types
+    pub fn telepathy_types(&self) -> impl Iterator<Item = &telepathy::TypeDef> {
+        self.children.iter().filter_map(|child| {
+            if let Child::TelepathyTypeDef(t) = child {
+                Some(t)
+            } else {
+                None
+            }
+        })
     }
 
     fn write_xml<W: Write>(&self, w: &mut W) -> std::io::Result<()> {
         write!(w, "<interface name=\"{}\"", escape(self.name.as_str()))?;
-        if self.methods.is_empty()
-            && self.properties.is_empty()
-            && self.signals.is_empty()
-            && self.annotations.is_empty()
-        {
+        if !self.children.iter().any(|child| {
+            matches!(
+                child,
+                Child::Method(_) | Child::Signal(_) | Child::Property(_) | Child::Annotation(_)
+            )
+        }) {
             return write!(w, "/>");
         }
         write!(w, ">")?;
-        for method in &self.methods {
-            method.write_xml(w)?;
-        }
-        for property in &self.properties {
-            property.write_xml(w)?;
-        }
-        for signal in &self.signals {
-            signal.write_xml(w)?;
-        }
-        for annotation in &self.annotations {
-            annotation.write_xml(w)?;
+        for child in &self.children {
+            child.write_xml(w)?;
         }
         write!(w, "</interface>")
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub enum Child<'a> {
+    #[serde(borrow)]
+    Method(Method<'a>),
+    #[serde(borrow)]
+    Property(Property<'a>),
+    #[serde(borrow)]
+    Signal(Signal<'a>),
+    Annotation(Annotation),
+    Docstring(String),
+    #[serde(skip)]
+    TelepathyTypeDef(telepathy::TypeDef),
+}
+
+impl<'a> From<Method<'a>> for Child<'a> {
+    fn from(method: Method<'a>) -> Self {
+        Self::Method(method)
+    }
+}
+
+impl<'a> From<Property<'a>> for Child<'a> {
+    fn from(property: Property<'a>) -> Self {
+        Self::Property(property)
+    }
+}
+
+impl<'a> From<Signal<'a>> for Child<'a> {
+    fn from(signal: Signal<'a>) -> Self {
+        Self::Signal(signal)
+    }
+}
+
+impl<'a> From<Annotation> for Child<'a> {
+    fn from(annotation: Annotation) -> Self {
+        Self::Annotation(annotation)
+    }
+}
+
+impl<'a> From<String> for Child<'a> {
+    fn from(docstring: String) -> Self {
+        Self::Docstring(docstring)
+    }
+}
+
+impl<'a> From<telepathy::TypeDef> for Child<'a> {
+    fn from(type_def: telepathy::TypeDef) -> Self {
+        Self::TelepathyTypeDef(type_def)
+    }
+}
+
+impl<'a> Child<'a> {
+    fn write_xml<W: Write>(&'a self, w: &mut W) -> std::io::Result<()> {
+        match self {
+            Self::Method(m) => m.write_xml(w),
+            Self::Property(p) => p.write_xml(w),
+            Self::Signal(s) => s.write_xml(w),
+            Self::Annotation(a) => a.write_xml(w),
+            Self::Docstring(_) => Ok(()),
+            Self::TelepathyTypeDef(_) => Ok(()),
+        }
+    }
+}
+
 /// An introspection tree node (typically the root of the XML document).
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 pub struct Node<'a> {

zbus_xml/src/xml.rs

@@ -249,40 +249,37 @@ fn interface<'i>(
     self_closing: bool,
 ) -> PResult<Interface<'static>> {
     let name = attrs.name(|n| InterfaceName::try_from(n).map_err(Error::Zbus))?;
-    let mut methods = Vec::new();
-    let mut properties = Vec::new();
-    let mut signals = Vec::new();
-    let mut annotations = Vec::new();
-    let mut docstring = None;
-    let mut telepathy_types = Vec::new();
+    let mut interface_children = Vec::<crate::Child<'static>>::new();
     children(
         input,
         tag,
         self_closing,
         |input, child, attrs, sc| match child {
             "method" => {
-                methods.push(method(input, child, attrs, sc)?);
+                interface_children.push(method(input, child, attrs, sc)?.into());
                 Ok(true)
             }
             "property" => {
-                properties.push(property(input, child, attrs, sc)?);
+                interface_children.push(property(input, child, attrs, sc)?.into());
                 Ok(true)
             }
             "signal" => {
-                signals.push(signal(input, child, attrs, sc)?);
+                interface_children.push(signal(input, child, attrs, sc)?.into());
                 Ok(true)
             }
             "annotation" => {
-                annotations.push(annotation(input, child, attrs, sc)?);
+                interface_children.push(annotation(input, child, attrs, sc)?.into());
                 Ok(true)
             }
             other if is_docstring(other) => {
-                docstring = capture_docstring(input, other, sc)?.or(docstring.take());
+                if let Some(docstring) = capture_docstring(input, other, sc)? {
+                    interface_children.push(docstring.into());
+                }
                 Ok(true)
             }
             other => {
                 if let Some(def) = telepathy_type_def(input, other, &attrs, sc)? {
-                    telepathy_types.push(def);
+                    interface_children.push(def.into());
                 }
                 Ok(true)
             }
@@ -291,12 +288,7 @@ fn interface<'i>(
 
     Ok(Interface {
         name,
-        methods,
-        properties,
-        signals,
-        annotations,
-        docstring,
-        telepathy_types,
+        children: interface_children,
     })
 }