Skip to main content

docx_rs/reader/
document.rs

1use std::io::Read;
2use std::str::FromStr;
3
4use crate::reader::*;
5
6use super::{Paragraph, Table};
7
8impl FromXML for Document {
9    fn from_xml<R: Read>(reader: R) -> Result<Self, ReaderError> {
10        let mut parser = EventReader::new(reader);
11        let mut doc = Self::default();
12        loop {
13            let e = parser.next();
14            match e {
15                Ok(XmlEvent::StartElement {
16                    attributes, name, ..
17                }) => {
18                    let e = XMLElement::from_str(&name.local_name).unwrap();
19                    match e {
20                        XMLElement::Paragraph => {
21                            let p = Paragraph::read(&mut parser, &attributes)?;
22                            doc = doc.add_paragraph(p);
23                            continue;
24                        }
25                        XMLElement::Table => {
26                            let t = Table::read(&mut parser, &attributes)?;
27                            doc = doc.add_table(t);
28                            continue;
29                        }
30                        XMLElement::BookmarkStart => {
31                            let s = BookmarkStart::read(&mut parser, &attributes)?;
32                            doc = doc.add_bookmark_start(s.id, s.name);
33                            continue;
34                        }
35                        XMLElement::BookmarkEnd => {
36                            let e = BookmarkEnd::read(&mut parser, &attributes)?;
37                            doc = doc.add_bookmark_end(e.id);
38                            continue;
39                        }
40                        XMLElement::CommentRangeStart => {
41                            if let Some(id) = read(&attributes, "id") {
42                                if let Ok(id) = usize::from_str(&id) {
43                                    let comment = Comment::new(id);
44                                    doc = doc.add_comment_start(comment);
45                                }
46                            }
47                            continue;
48                        }
49                        XMLElement::CommentRangeEnd => {
50                            if let Some(id) = read(&attributes, "id") {
51                                if let Ok(id) = usize::from_str(&id) {
52                                    doc = doc.add_comment_end(id);
53                                }
54                            }
55                            continue;
56                        }
57                        XMLElement::SectionProperty => {
58                            let e = SectionProperty::read(&mut parser, &attributes)?;
59                            doc = doc.default_section_property(e);
60                            continue;
61                        }
62                        XMLElement::StructuredDataTag => {
63                            if let Ok(tag) = StructuredDataTag::read(&mut parser, &attributes) {
64                                doc = doc.add_structured_data_tag(tag);
65                            }
66                            continue;
67                        }
68                        _ => {}
69                    }
70                }
71                Ok(XmlEvent::EndDocument) => break,
72                Err(_) => return Err(ReaderError::XMLReadError),
73                _ => {}
74            }
75        }
76        Ok(doc)
77    }
78}