Enum Nonza

pub enum Nonza {
    Enable(Enable),
    Enabled(Enabled),
    Resume(Resume),
    Resumed(Resumed),
    Failed(Failed),
    Ack(A),
    Req(R),
}

Enum which allows parsing/serialising any XEP-0198 element.

Variants

Enable(Enable)

Request to enable SM

Enabled(Enabled)

Successful SM enablement response

Resume(Resume)

Request to resume SM

Resumed(Resumed)

 Sucessful SM resumption response

Failed(Failed)

Error response

Ack(A)

Acknowledgement

Req(R)

Request for an acknowledgement

Trait Implementations

impl AsXml for Nonza

type ItemIter<'xso_proc_as_xml_iter_lifetime> = NonzaAsXmlIterator<'xso_proc_as_xml_iter_lifetime>

The iterator type.

fn as_xml_iter(&self) -> Result<Self::ItemIter<'_>, Error>

Return an iterator which emits the contents of the struct or enum as serialisable Item items.

fn as_xml_dyn_iter<'x>( &'x self, ) -> Result<Box<dyn Iterator<Item = Result<Item<'x>, Error>> + 'x>, Error>

Return the same iterator as as_xml_iter, but boxed to erase the concrete iterator type.

impl Clone for Nonza

fn clone(&self) -> Nonza

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Nonza

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&Nonza> for Element

fn from(other: &Nonza) -> Self

Converts to this type from the input type.

impl From<Nonza> for Element

fn from(other: Nonza) -> Self

Converts to this type from the input type.

impl FromXml for Nonza

type Builder = NonzaFromXmlBuilder

A builder type used to construct the element.

fn from_events( name: QName, attrs: AttrMap, ctx: &Context<'_>, ) -> Result<Self::Builder, FromEventsError>

Attempt to initiate the streamed construction of this struct from XML.

fn xml_name_matcher() -> XmlNameMatcher<'static>

Return a predicate which determines if Self may be parsed from a given XML element.

impl PartialEq for Nonza

fn eq(&self, other: &Nonza) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Element> for Nonza

type Error = FromElementError

The type returned in the event of a conversion error.

fn try_from(other: Element) -> Result<Self, FromElementError>

Performs the conversion.

impl StructuralPartialEq for Nonza