1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
use std::str::FromStr;
use peanuts::element::{FromElement, IntoElement};
use peanuts::{DeserializeError, Element};
use crate::stanza_error::Error as StanzaError;
use crate::stanza_error::Text;
use super::XMLNS;
#[derive(Clone, Debug)]
pub struct Error {
by: Option<String>,
r#type: ErrorType,
// children (sequence)
error: StanzaError,
text: Option<Text>,
}
impl FromElement for Error {
fn from_element(mut element: peanuts::Element) -> peanuts::element::DeserializeResult<Self> {
element.check_name("error")?;
element.check_name(XMLNS)?;
let by = element.attribute_opt("by")?;
let r#type = element.attribute("type")?;
let error = element.pop_child_one()?;
let text = element.pop_child_opt()?;
Ok(Error {
by,
r#type,
error,
text,
})
}
}
impl IntoElement for Error {
fn builder(&self) -> peanuts::element::ElementBuilder {
Element::builder("error", Some(XMLNS))
.push_attribute_opt("by", self.by.clone())
.push_attribute("type", self.r#type)
.push_child(self.error.clone())
.push_child_opt(self.text.clone())
}
}
#[derive(Copy, Clone, Debug)]
pub enum ErrorType {
Auth,
Cancel,
Continue,
Modify,
Wait,
}
impl FromStr for ErrorType {
type Err = DeserializeError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"auth" => Ok(ErrorType::Auth),
"cancel" => Ok(ErrorType::Cancel),
"continue" => Ok(ErrorType::Continue),
"modify" => Ok(ErrorType::Modify),
"wait" => Ok(ErrorType::Wait),
_ => Err(DeserializeError::FromStr(s.to_string())),
}
}
}
impl ToString for ErrorType {
fn to_string(&self) -> String {
match self {
ErrorType::Auth => "auth".to_string(),
ErrorType::Cancel => "cancel".to_string(),
ErrorType::Continue => "continue".to_string(),
ErrorType::Modify => "modify".to_string(),
ErrorType::Wait => "wait".to_string(),
}
}
}
|
