hxml 0.3.3

XML Engine
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

pub mod dom;
mod err;
mod gstring;
mod node;
mod predicate;
mod parse;
mod utils;

#[cfg(test)]
mod testbench;

pub use err::HxmlError;
pub use node::attribute::Attribute;
pub use node::element::{Content, Element};
pub use node::pointer::ElementPtr;
pub use node::prolog::Prolog;

use err::{reset_errors, read_errors};
use gstring::set_global_string;
use node::memory;
use utils::into_v16;
use parse::{get_prolog_end_index, parse_element, parse_prolog};
use std::collections::HashMap;

/// It's global.
/// You can't handle multiple doms at once.
/// It frees all the elements created before.
pub fn into_dom(document: String) -> Result<(), HxmlError> {
    memory::init();

    unsafe {
        dom::PROLOG = None;
        dom::TAGS_BY_NAME = Some(HashMap::new());
        dom::TAGS_BY_ID = Some(HashMap::new());
        dom::TAGS_BY_CLASS = Some(HashMap::new());
    }

    let document = into_v16(&document);
    set_global_string(document.clone());
    reset_errors();

    let mut curr_index = 0;

    match get_prolog_end_index(&document, curr_index) {
        Some(end_index) => {
            unsafe {
                dom::PROLOG = Some(parse_prolog(&document, curr_index).0);
            }
            curr_index = end_index + 1;
        },
        None => {}
    }

    match parse_element(&document, curr_index) {
        Some((element, _)) => {
            let result = element.to_real();
            result.set_parent_recursive();
            return Ok(());
        },
        None => {}
    }

    let errors = read_errors();

    // reset global states
    set_global_string(vec![]);
    reset_errors();

    if errors.len() > 0 {
        return Err(errors[0].clone());
    }

    return Err(HxmlError::new(String::from("Unexpected Eof!"), usize::MAX));
}

#[cfg(test)]
mod tests {
    use std::fs::File;
    use std::io::Read;
    use crate::dom;

    #[test]
    fn file_test() {
        let mut f = File::open("./tests/test1.html").unwrap();
        let mut s = String::new();

        f.read_to_string(&mut s).unwrap();

        let lock = unsafe {
            dom::LOCK.lock().unwrap()
        };

        crate::into_dom(s).unwrap();
        dom::some_checks().unwrap();

        drop(lock);
    }

}