path: root/stanza/src/starttls.rs

use peanuts::{Element, FromElement, IntoElement};

pub const XMLNS: &str = "urn:ietf:params:xml:ns:xmpp-tls";

#[derive(Debug, Clone)]
pub struct StartTls {
    pub required: bool,
}

impl IntoElement for StartTls {
    fn builder(&self) -> peanuts::ElementBuilder {
        let mut builder = Element::builder("starttls", Some(XMLNS));

        if self.required {
            builder = builder.push_child(Required)
        }

        builder
    }
}

impl FromElement for StartTls {
    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::DeserializeResult<Self> {
        element.check_name("required")?;
        element.check_namespace(XMLNS)?;

        Ok(Required)
    }
}

impl IntoElement for Required {
    fn builder(&self) -> peanuts::ElementBuilder {
        Element::builder("required", Some(XMLNS))
    }
}

#[derive(Debug)]
pub struct Proceed;

impl IntoElement for Proceed {
    fn builder(&self) -> peanuts::ElementBuilder {
        Element::builder("proceed", Some(XMLNS))
    }
}

impl FromElement for Proceed {
    fn from_element(element: Element) -> peanuts::DeserializeResult<Self> {
        element.check_name("proceed")?;
        element.check_namespace(XMLNS)?;

        Ok(Proceed)
    }
}

pub struct Failure;

impl IntoElement for Failure {
    fn builder(&self) -> peanuts::ElementBuilder {
        Element::builder("failure", Some(XMLNS))
    }
}

impl FromElement for Failure {
    fn from_element(element: Element) -> peanuts::DeserializeResult<Self> {
        element.check_name("failure")?;
        element.check_namespace(XMLNS)?;

        Ok(Failure)
    }
}