xlsbye-xml 0.1.0

SpreadsheetML XML writer for xlsbye
Documentation 
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use quick_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
use quick_xml::Writer;
use std::io::Write;

pub type Result<T> = std::io::Result<T>;

pub struct XmlWriter<W: Write> {
    inner: Writer<W>,
}

impl<W: Write> XmlWriter<W> {
    pub fn new(writer: W) -> Self {
        Self {
            inner: Writer::new_with_indent(writer, b' ', 2),
        }
    }

    pub fn into_inner(self) -> W {
        self.inner.into_inner()
    }

    pub fn writer(&mut self) -> &mut Writer<W> {
        &mut self.inner
    }

    pub fn write_xml_declaration(&mut self) -> Result<()> {
        self.inner
            .write_event(Event::Decl(BytesDecl::new("1.0", Some("UTF-8"), Some("yes"))))
    }

    pub fn write_start_element<I, K, V>(&mut self, name: &str, attrs: I) -> Result<()>
    where
        I: IntoIterator<Item = (K, V)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        let mut element = BytesStart::new(name);
        for (key, value) in attrs {
            element.push_attribute((key.as_ref(), value.as_ref()));
        }
        self.inner.write_event(Event::Start(element))
    }

    pub fn write_empty_element<I, K, V>(&mut self, name: &str, attrs: I) -> Result<()>
    where
        I: IntoIterator<Item = (K, V)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        let mut element = BytesStart::new(name);
        for (key, value) in attrs {
            element.push_attribute((key.as_ref(), value.as_ref()));
        }
        self.inner.write_event(Event::Empty(element))
    }

    pub fn write_start_element_with_ns<I, N, K1, V1, K2, V2>(
        &mut self,
        name: &str,
        namespaces: N,
        attrs: I,
    ) -> Result<()>
    where
        I: IntoIterator<Item = (K1, V1)>,
        N: IntoIterator<Item = (K2, V2)>,
        K1: AsRef<str>,
        V1: AsRef<str>,
        K2: AsRef<str>,
        V2: AsRef<str>,
    {
        let mut element = BytesStart::new(name);

        for (prefix, uri) in namespaces {
            if prefix.as_ref().is_empty() {
                element.push_attribute(("xmlns", uri.as_ref()));
            } else {
                let key = format!("xmlns:{}", prefix.as_ref());
                element.push_attribute((key.as_str(), uri.as_ref()));
            }
        }

        for (key, value) in attrs {
            element.push_attribute((key.as_ref(), value.as_ref()));
        }

        self.inner.write_event(Event::Start(element))
    }

    pub fn write_end_element(&mut self, name: &str) -> Result<()> {
        self.inner.write_event(Event::End(BytesEnd::new(name)))
    }

    pub fn write_text(&mut self, text: &str) -> Result<()> {
        self.inner.write_event(Event::Text(BytesText::new(text)))
    }

    pub fn write_text_element<I, K, V>(&mut self, name: &str, attrs: I, text: &str) -> Result<()>
    where
        I: IntoIterator<Item = (K, V)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        self.write_start_element(name, attrs)?;
        self.write_text(text)?;
        self.write_end_element(name)
    }
}