xml-data 0.0.1

Generic XML parsing and serializing
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

#![allow(missing_docs)] // names should be good enough
//! Helper functions to generate common errors

use crate::{
	Error,
};
use std::fmt;

pub(crate) enum ParseError {
	UnexpectedEof { msg: String },
	UnexpectedEnd,
	UnexpectedDecl,
	UnexpectedDocType,
	UnexpectedPI,
	UnexpectedText,
	UnexpectedElement { tag: String },
	UnexpectedAttribute { key: String },
	InnerElementNotParsed { tag: String },
	MissingElement { tag: String },
	MissingUnknownElement,
	MissingAttribute { key: String },
}

impl fmt::Debug for ParseError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self {
			Self::UnexpectedEof { msg } => write!(f, "unexpected eof: {}", msg),
			Self::UnexpectedEnd => write!(f, "Unexpected end tag"),
			Self::UnexpectedDecl => write!(f, "Unexpected decl <?xml ... ?>"),
			Self::UnexpectedDocType => write!(f, "Unexpected <!DOCTYPE ...>"),
			Self::UnexpectedPI => write!(f, "Unexpected processing instructions <?...?>"),
			Self::UnexpectedText => write!(f, "Unexpected (non-whitespace) text/CDATA"),
			Self::UnexpectedElement { tag } => write!(f, "Unexpected element: {}", tag),
			Self::UnexpectedAttribute { key } => write!(f, "Unexpected attribute: {}", key),
			Self::InnerElementNotParsed { tag } => write!(f, "Inner element {:?} wasn't fully parsed", tag),
			Self::MissingElement { tag } => write!(f, "Missing element {:?}", tag),
			Self::MissingUnknownElement => write!(f, "Missing element"),
			Self::MissingAttribute { key } => write!(f, "Missing attribute {:?}", key),
		}
	}
}

impl fmt::Display for ParseError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Debug::fmt(self, f)
	}
}

impl std::error::Error for ParseError {
}

pub fn unexpected_eof(msg: &str) -> Error {
	ParseError::UnexpectedEof { msg: msg.into() }.into()
}

pub fn unexpected_end() -> Error {
	ParseError::UnexpectedEnd.into()
}

pub fn unexpected_decl() -> Error {
	ParseError::UnexpectedDecl.into()
}

pub fn unexpected_doctype() -> Error {
	ParseError::UnexpectedDocType.into()
}

pub fn unexpected_pi() -> Error {
	ParseError::UnexpectedPI.into()
}

pub fn unexpected_text() -> Error {
	ParseError::UnexpectedText.into()
}

pub fn unexpected_element(tag: &str) -> Error {
	ParseError::UnexpectedElement { tag: tag.into() }.into()
}

pub fn unexpected_attribute(key: &str) -> Error {
	ParseError::UnexpectedAttribute { key: key.into() }.into()
}

pub fn inner_element_not_parsed(tag: &str) -> Error {
	ParseError::InnerElementNotParsed { tag: tag.into() }.into()
}

pub fn missing_element(tag: &str) -> Error {
	ParseError::MissingElement { tag: tag.into() }.into()
}

pub fn missing_unknown_element() -> Error {
	ParseError::MissingUnknownElement.into()
}

pub fn missing_attribute(key: &str) -> Error {
	ParseError::MissingAttribute { key: key.into() }.into()
}