1use minidom::Element;
2
3use error::Error;
4
5use ns;
6
7#[derive(Debug, Clone)]
8pub struct First {
9 pub index: Option<usize>,
10 pub base: String,
11}
12
13#[derive(Debug, Clone)]
14pub struct Set {
15 pub after: Option<String>,
16 pub before: Option<String>,
17 pub count: Option<usize>,
18 pub first: Option<First>,
19 pub index: Option<usize>,
20 pub last: Option<String>,
21 pub max: Option<usize>,
22}
23
24pub fn parse_rsm(root: &Element) -> Result<Set, Error> {
25 if !root.is("set", ns::RSM) {
26 return Err(Error::ParseError("This is not a RSM element."));
27 }
28 let mut after = None;
29 let mut before = None;
30 let mut count = None;
31 let mut first = None;
32 let mut index = None;
33 let mut last = None;
34 let mut max = None;
35 for child in root.children() {
36 if child.is("after", ns::RSM) {
37 if after.is_some() {
38 return Err(Error::ParseError("Set can’t have more than one after."));
39 }
40 after = Some(child.text());
41 } else if child.is("before", ns::RSM) {
42 if before.is_some() {
43 return Err(Error::ParseError("Set can’t have more than one before."));
44 }
45 before = Some(child.text());
46 } else if child.is("count", ns::RSM) {
47 if count.is_some() {
48 return Err(Error::ParseError("Set can’t have more than one count."));
49 }
50 count = Some(child.text().parse()?);
51 } else if child.is("first", ns::RSM) {
52 if first.is_some() {
53 return Err(Error::ParseError("Set can’t have more than one first."));
54 }
55 first = Some(First {
56 index: match child.attr("index") {
57 Some(index) => Some(index.parse()?),
58 None => None,
59 },
60 base: child.text(),
61 });
62 } else if child.is("index", ns::RSM) {
63 if index.is_some() {
64 return Err(Error::ParseError("Set can’t have more than one index."));
65 }
66 index = Some(child.text().parse()?);
67 } else if child.is("last", ns::RSM) {
68 if last.is_some() {
69 return Err(Error::ParseError("Set can’t have more than one last."));
70 }
71 last = Some(child.text());
72 } else if child.is("max", ns::RSM) {
73 if max.is_some() {
74 return Err(Error::ParseError("Set can’t have more than one max."));
75 }
76 max = Some(child.text().parse()?);
77 } else {
78 return Err(Error::ParseError("Unknown child in set element."));
79 }
80 }
81 Ok(Set {
82 after: after,
83 before: before,
84 count: count,
85 first: first,
86 index: index,
87 last: last,
88 max: max,
89 })
90}
91
92pub fn serialise(rsm: &Set) -> Element {
93 let mut elem = Element::builder("set")
94 .ns(ns::RSM)
95 .build();
96 if rsm.after.is_some() {
97 elem.append_child(Element::builder("after").ns(ns::RSM).append(rsm.after.clone()).build());
98 }
99 if rsm.before.is_some() {
100 elem.append_child(Element::builder("before").ns(ns::RSM).append(rsm.before.clone()).build());
101 }
102 if rsm.count.is_some() {
103 elem.append_child(Element::builder("count").ns(ns::RSM).append(format!("{}", rsm.count.unwrap())).build());
104 }
105 if rsm.first.is_some() {
106 let first = rsm.first.clone().unwrap();
107 elem.append_child(Element::builder("first")
108 .ns(ns::RSM)
109 .attr("index", match first.index {
110 Some(index) => Some(format!("{}", index)),
111 None => None,
112 })
113 .append(first.base.clone()).build());
114 }
115 if rsm.index.is_some() {
116 elem.append_child(Element::builder("index").ns(ns::RSM).append(format!("{}", rsm.index.unwrap())).build());
117 }
118 if rsm.last.is_some() {
119 elem.append_child(Element::builder("last").ns(ns::RSM).append(rsm.last.clone()).build());
120 }
121 if rsm.max.is_some() {
122 elem.append_child(Element::builder("max").ns(ns::RSM).append(format!("{}", rsm.max.unwrap())).build());
123 }
124 elem
125}
126
127#[cfg(test)]
128mod tests {
129 use minidom::Element;
130 use error::Error;
131 use rsm;
132
133 #[test]
134 fn test_simple() {
135 let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>".parse().unwrap();
136 let set = rsm::parse_rsm(&elem).unwrap();
137 assert_eq!(set.after, None);
138 assert_eq!(set.before, None);
139 assert_eq!(set.count, None);
140 match set.first {
141 Some(_) => panic!(),
142 None => (),
143 }
144 assert_eq!(set.index, None);
145 assert_eq!(set.last, None);
146 assert_eq!(set.max, None);
147 }
148
149 #[test]
150 fn test_unknown() {
151 let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
152 let error = rsm::parse_rsm(&elem).unwrap_err();
153 let message = match error {
154 Error::ParseError(string) => string,
155 _ => panic!(),
156 };
157 assert_eq!(message, "This is not a RSM element.");
158 }
159
160 #[test]
161 fn test_invalid_child() {
162 let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><coucou/></set>".parse().unwrap();
163 let error = rsm::parse_rsm(&elem).unwrap_err();
164 let message = match error {
165 Error::ParseError(string) => string,
166 _ => panic!(),
167 };
168 assert_eq!(message, "Unknown child in set element.");
169 }
170
171 #[test]
172 fn test_serialise() {
173 let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>".parse().unwrap();
174 let rsm = rsm::Set {
175 after: None,
176 before: None,
177 count: None,
178 first: None,
179 index: None,
180 last: None,
181 max: None,
182 };
183 let elem2 = rsm::serialise(&rsm);
184 assert_eq!(elem, elem2);
185 }
186}