use std::fmt::Write;
use crate::*;
impl Xml {
pub fn into_document(self) -> Option<Document> {
if self.0.len() != 1 { return None; }
let root = self.0.into_iter().next().unwrap();
if let Content::Tag(root) = root {
Some(Document {
root,
xml_decl_attrs: Vec::new(),
doctype: None,
})
} else {
None
}
}
}
impl Document {
pub fn with_xml_attr(mut self, name: &str, value: impl Into<String>) -> Self {
let value = value.into();
if let Some((_, v)) = self.xml_decl_attrs.iter_mut().find(|(n, _)| n == name) {
*v = value;
} else {
self.xml_decl_attrs.push((name.to_owned(), value));
}
self
}
pub fn with_xml_version(self, version: impl Into<String>) -> Self {
self.with_xml_attr("version", version)
}
pub fn with_xml_encoding(self, encoding: impl Into<String>) -> Self {
self.with_xml_attr("encoding", encoding)
}
pub fn with_doctype(mut self, doctype: impl Into<String>) -> Self {
self.doctype = Some(doctype.into());
self
}
}
fn escape(s: &str) -> String {
s.chars().fold(String::new(), |mut s, ch| match ch {
'<' => s + "<",
'>' => s + ">",
'&' => s + "&",
'\'' => s + "'",
'"' => s + """,
_ => { write!(&mut s, "{ch}").unwrap(); s },
})
}
impl ToXml for Xml {
fn to_xml(&self) -> Xml {
self.clone()
}
}
impl ToXml for Tag {
fn to_xml(&self) -> Xml {
Xml(vec![Content::Tag(self.clone())])
}
}
impl ToXml for &str {
fn to_xml(&self) -> Xml {
Xml(vec![Content::Word(escape(self))])
}
}
impl ToXml for String {
fn to_xml(&self) -> Xml {
self.as_str().to_xml()
}
}
impl ToXml for char {
fn to_xml(&self) -> Xml {
Xml(vec![Content::Word(escape(&self.to_string()))])
}
}
impl<T: ToXml> ToXml for Vec<T> {
fn to_xml(&self) -> Xml {
let contents = self.iter()
.map(|x| x.to_xml())
.map(|mut x| {
if x.0.len() == 1 {
x.0.drain(0..1).next().unwrap()
} else {
Content::Nested(x)
}
})
.collect();
Xml(contents)
}
}
impl<T: ToXml> ToXml for Option<T> {
fn to_xml(&self) -> Xml {
match self {
Some(x) => x.to_xml(),
None => Xml::default(),
}
}
}
impl<T: ToXml, E: ToXml> ToXml for Result<T, E> {
fn to_xml(&self) -> Xml {
match self {
Ok(x) => x.to_xml(),
Err(x) => x.to_xml(),
}
}
}
impl<T: ToXml> ToXml for &T {
fn to_xml(&self) -> Xml {
(*self).to_xml()
}
}
macro_rules! simple_impl {
($t:ty) => {
impl ToXml for $t {
fn to_xml(&self) -> Xml {
Xml(vec![Content::Word(self.to_string())])
}
}
};
}
simple_impl!(u8);
simple_impl!(u16);
simple_impl!(u32);
simple_impl!(u64);
simple_impl!(u128);
simple_impl!(usize);
simple_impl!(i8);
simple_impl!(i16);
simple_impl!(i32);
simple_impl!(i64);
simple_impl!(i128);
simple_impl!(isize);
simple_impl!(bool);
impl<T, I> CollectXml for I
where
T: ToXml,
I: Iterator<Item = T>,
{
fn collect_xml(self) -> Xml {
let inner = self.map(|x| x.to_xml().0).flatten().collect();
Xml(inner)
}
}