1 files changed, 45 insertions, 105 deletions

diff --git a/src/stanza/starttls.rs b/src/stanza/starttls.rs
index ee35bf5..33721ab 100644
--- a/src/stanza/starttls.rs
+++ b/src/stanza/starttls.rs
@@ -7,76 +7,48 @@ use peanuts::{
 
 pub const XMLNS: &str = "urn:ietf:params:xml:ns:xmpp-tls";
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct StartTls {
     pub required: bool,
 }
 
 impl IntoElement for StartTls {
-    fn into_element(&self) -> peanuts::Element {
-        let content;
-        if self.required == true {
-            let element = Content::Element(Element {
-                name: Name {
-                    namespace: Some(XMLNS.to_string()),
-                    local_name: "required".to_string(),
-                },
-                namespace_declaration_overrides: HashSet::new(),
-                attributes: HashMap::new(),
-                content: Vec::new(),
-            });
-            content = vec![element];
-        } else {
-            content = Vec::new();
-        }
-        Element {
-            name: Name {
-                namespace: Some(XMLNS.to_string()),
-                local_name: "starttls".to_string(),
-            },
-            namespace_declaration_overrides: HashSet::new(),
-            attributes: HashMap::new(),
-            content,
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        let mut builder = Element::builder("starttls", Some(XMLNS));
+
+        if self.required {
+            builder = builder.push_child(Element::builder("required", Some(XMLNS)))
         }
+
+        builder
     }
 }
 
 impl FromElement for StartTls {
-    fn from_element(element: peanuts::Element) -> peanuts::Result<Self> {
-        let Name {
-            namespace,
-            local_name,
-        } = element.name;
-        if namespace.as_deref() == Some(XMLNS) && &local_name == "starttls" {
-            let mut required = false;
-            if element.content.len() == 1 {
-                match element.content.first().unwrap() {
-                    Content::Element(element) => {
-                        let Name {
-                            namespace,
-                            local_name,
-                        } = &element.name;
-
-                        if namespace.as_deref() == Some(XMLNS) && local_name == "required" {
-                            required = true
-                        } else {
-                            return Err(peanuts::Error::UnexpectedElement(element.name.clone()));
-                        }
-                    }
-                    c => return Err(peanuts::Error::UnexpectedContent((*c).clone())),
-                }
-            } else {
-                return Err(peanuts::Error::UnexpectedNumberOfContents(
-                    element.content.len(),
-                ));
-            }
-            return Ok(StartTls { required });
-        } else {
-            return Err(peanuts::Error::IncorrectName(Name {
-                namespace,
-                local_name,
-            }));
+    fn from_element(
+        mut element: peanuts::Element,
+    ) -> std::result::Result<StartTls, peanuts::DeserializeError> {
+        element.check_name("starttls")?;
+        element.check_namespace(XMLNS)?;
+
+        let mut required = false;
+        if let Some(_) = element.child_opt::<Required>()? {
+            required = true;
         }
+
+        Ok(StartTls { required })
+    }
+}
+
+#[derive(Debug)]
+pub struct Required;
+
+impl FromElement for Required {
+    fn from_element(element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("required")?;
+        element.check_namespace(XMLNS)?;
+
+        Ok(Required)
     }
 }
 
@@ -84,65 +56,33 @@ impl FromElement for StartTls {
 pub struct Proceed;
 
 impl IntoElement for Proceed {
-    fn into_element(&self) -> Element {
-        Element {
-            name: Name {
-                namespace: Some(XMLNS.to_string()),
-                local_name: "proceed".to_string(),
-            },
-            namespace_declaration_overrides: HashSet::new(),
-            attributes: HashMap::new(),
-            content: Vec::new(),
-        }
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("proceed", Some(XMLNS))
     }
 }
 
 impl FromElement for Proceed {
-    fn from_element(element: Element) -> peanuts::Result<Self> {
-        let Name {
-            namespace,
-            local_name,
-        } = element.name;
-        if namespace.as_deref() == Some(XMLNS) && &local_name == "proceed" {
-            return Ok(Proceed);
-        } else {
-            return Err(peanuts::Error::IncorrectName(Name {
-                namespace,
-                local_name,
-            }));
-        }
+    fn from_element(element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("proceed")?;
+        element.check_namespace(XMLNS)?;
+
+        Ok(Proceed)
     }
 }
 
 pub struct Failure;
 
 impl IntoElement for Failure {
-    fn into_element(&self) -> Element {
-        Element {
-            name: Name {
-                namespace: Some(XMLNS.to_string()),
-                local_name: "failure".to_string(),
-            },
-            namespace_declaration_overrides: HashSet::new(),
-            attributes: HashMap::new(),
-            content: Vec::new(),
-        }
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("failure", Some(XMLNS))
     }
 }
 
 impl FromElement for Failure {
-    fn from_element(element: Element) -> peanuts::Result<Self> {
-        let Name {
-            namespace,
-            local_name,
-        } = element.name;
-        if namespace.as_deref() == Some(XMLNS) && &local_name == "failure" {
-            return Ok(Failure);
-        } else {
-            return Err(peanuts::Error::IncorrectName(Name {
-                namespace,
-                local_name,
-            }));
-        }
+    fn from_element(element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("failure")?;
+        element.check_namespace(XMLNS)?;
+
+        Ok(Failure)
     }
 }