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

use crate::gstring::GString;
use crate::utils::{from_v16, into_v16};

#[derive(Clone)]
pub struct HxmlError {
    message: String
}

impl HxmlError {

    pub(crate) fn new(message: String, index: usize) -> Self {
        let message = {

            if index == usize::MAX {
                format!("Error: {}", message)
            }

            else {
                let lines = GString::all().split('\n' as u16);
                let mut error_line_index = 0;

                for (i, line) in lines.iter().enumerate() {

                    if line.end >= index {
                        error_line_index = i;
                        break;
                    }

                }

                let lines: Vec<Vec<u16>> = lines.iter().enumerate().map(
                    |(index, line)| {
                        let line = line.to_vec();

                        let line = if line.len() > 86 {
                            vec![
                                line[0..86].to_vec(),
                                vec!['.' as u16; 3]
                            ].concat()
                        } else {
                            line
                        };

                        let marker = if index == error_line_index {
                            into_v16(">>>")
                        } else {
                            vec![' ' as u16; 3]
                        };

                        let line_no = into_v16(&format!("{index:05} | "));

                        vec![marker, line_no, line].concat()
                    }
                ).collect();

                let line_output_start = error_line_index.max(3) - 3;
                let line_output_end = (line_output_start + 8).min(lines.len());

                let lines = lines[line_output_start..line_output_end].into_iter().map(|line| from_v16(&line)).collect::<Vec<String>>().join("\n");

                format!("Error: {}\n\n{lines}\n", message)
            }

        };
        HxmlError { message }
    }

}

impl std::fmt::Debug for HxmlError {

    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(fmt, "{}", self.message)
    }

}

impl std::fmt::Display for HxmlError {

    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(fmt, "{}", self.message)
    }

}

pub static mut ERRORS: Vec<HxmlError> = vec![];

pub fn reset_errors() {
    unsafe { ERRORS = vec![]; }
}

pub fn read_errors() -> Vec<HxmlError> {
    unsafe { ERRORS.clone() }
}

pub fn raise_error(e: HxmlError) {
    unsafe { ERRORS.push(e); }
}